Add files using upload-large-folder tool

llmeval-env/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/INSTALLER

@@ -0,0 +1 @@
+pip

llmeval-env/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/LICENSE

@@ -0,0 +1,20 @@
+This package contains a modified version of ca-bundle.crt:
+
+ca-bundle.crt -- Bundle of CA Root Certificates
+
+This is a bundle of X.509 certificates of public Certificate Authorities
+(CA). These were automatically extracted from Mozilla's root certificates
+file (certdata.txt).  This file can be found in the mozilla source tree:
+https://hg.mozilla.org/mozilla-central/file/tip/security/nss/lib/ckfw/builtins/certdata.txt
+It contains the certificates in PEM format and therefore
+can be directly used with curl / libcurl / php_curl, or with
+an Apache+mod_ssl webserver for SSL client authentication.
+Just configure this file as the SSLCACertificateFile.#
+
+***** BEGIN LICENSE BLOCK *****
+This Source Code Form is subject to the terms of the Mozilla Public License,
+v. 2.0. If a copy of the MPL was not distributed with this file, You can obtain
+one at http://mozilla.org/MPL/2.0/.
+
+***** END LICENSE BLOCK *****
+@(#) $RCSfile: certdata.txt,v $ $Revision: 1.80 $ $Date: 2011/11/03 15:11:58 $

llmeval-env/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/METADATA

@@ -0,0 +1,66 @@
+Metadata-Version: 2.1
+Name: certifi
+Version: 2024.2.2
+Summary: Python package for providing Mozilla's CA Bundle.
+Home-page: https://github.com/certifi/python-certifi
+Author: Kenneth Reitz
+Author-email: [email protected]
+License: MPL-2.0
+Project-URL: Source, https://github.com/certifi/python-certifi
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: Mozilla Public License 2.0 (MPL 2.0)
+Classifier: Natural Language :: English
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Programming Language :: Python :: 3.6
+Classifier: Programming Language :: Python :: 3.7
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Requires-Python: >=3.6
+License-File: LICENSE
+
+Certifi: Python SSL Certificates
+================================
+
+Certifi provides Mozilla's carefully curated collection of Root Certificates for
+validating the trustworthiness of SSL certificates while verifying the identity
+of TLS hosts. It has been extracted from the `Requests`_ project.
+
+Installation
+------------
+
+``certifi`` is available on PyPI. Simply install it with ``pip``::
+
+    $ pip install certifi
+
+Usage
+-----
+
+To reference the installed certificate authority (CA) bundle, you can use the
+built-in function::
+
+    >>> import certifi
+
+    >>> certifi.where()
+    '/usr/local/lib/python3.7/site-packages/certifi/cacert.pem'
+
+Or from the command line::
+
+    $ python -m certifi
+    /usr/local/lib/python3.7/site-packages/certifi/cacert.pem
+
+Enjoy!
+
+.. _`Requests`: https://requests.readthedocs.io/en/master/
+
+Addition/Removal of Certificates
+--------------------------------
+
+Certifi does not support any addition/removal or other modification of the
+CA trust store content. This project is intended to provide a reliable and
+highly portable root of trust to python deployments. Look to upstream projects
+for methods to use alternate trust.

llmeval-env/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/RECORD

@@ -0,0 +1,14 @@
+certifi-2024.2.2.dist-info/INSTALLER,sha256=zuuue4knoyJ-UwPPXg8fezS7VCrXJQrAP7zeNuwvFQg,4
+certifi-2024.2.2.dist-info/LICENSE,sha256=6TcW2mucDVpKHfYP5pWzcPBpVgPSH2-D8FPkLPwQyvc,989
+certifi-2024.2.2.dist-info/METADATA,sha256=1noreLRChpOgeSj0uJT1mehiBl8ngh33Guc7KdvzYYM,2170
+certifi-2024.2.2.dist-info/RECORD,,
+certifi-2024.2.2.dist-info/WHEEL,sha256=oiQVh_5PnQM0E3gPdiz09WCNmwiHDMaGer_elqB3coM,92
+certifi-2024.2.2.dist-info/top_level.txt,sha256=KMu4vUCfsjLrkPbSNdgdekS-pVJzBAJFO__nI8NF6-U,8
+certifi/__init__.py,sha256=ljtEx-EmmPpTe2SOd5Kzsujm_lUD0fKJVnE9gzce320,94
+certifi/__main__.py,sha256=xBBoj905TUWBLRGANOcf7oi6e-3dMP4cEoG9OyMs11g,243
+certifi/__pycache__/__init__.cpython-310.pyc,,
+certifi/__pycache__/__main__.cpython-310.pyc,,
+certifi/__pycache__/core.cpython-310.pyc,,
+certifi/cacert.pem,sha256=ejR8qP724p-CtuR4U1WmY1wX-nVeCUD2XxWqj8e9f5I,292541
+certifi/core.py,sha256=qRDDFyXVJwTB_EmoGppaXU_R9qCZvhl-EzxPMuV3nTA,4426
+certifi/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0

llmeval-env/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: bdist_wheel (0.42.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

llmeval-env/lib/python3.10/site-packages/certifi-2024.2.2.dist-info/top_level.txt

@@ -0,0 +1 @@
+certifi

llmeval-env/lib/python3.10/site-packages/nltk/VERSION

@@ -0,0 +1 @@
+3.8.1

llmeval-env/lib/python3.10/site-packages/nltk/__init__.py

@@ -0,0 +1,209 @@
+# Natural Language Toolkit (NLTK)
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <[email protected]>
+#          Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+The Natural Language Toolkit (NLTK) is an open source Python library
+for Natural Language Processing.  A free online book is available.
+(If you use the library for academic research, please cite the book.)
+
+Steven Bird, Ewan Klein, and Edward Loper (2009).
+Natural Language Processing with Python.  O'Reilly Media Inc.
+https://www.nltk.org/book/
+
+isort:skip_file
+"""
+
+import os
+
+# //////////////////////////////////////////////////////
+# Metadata
+# //////////////////////////////////////////////////////
+
+# Version.  For each new release, the version number should be updated
+# in the file VERSION.
+try:
+    # If a VERSION file exists, use it!
+    version_file = os.path.join(os.path.dirname(__file__), "VERSION")
+    with open(version_file) as infile:
+        __version__ = infile.read().strip()
+except NameError:
+    __version__ = "unknown (running code interactively?)"
+except OSError as ex:
+    __version__ = "unknown (%s)" % ex
+
+if __doc__ is not None:  # fix for the ``python -OO``
+    __doc__ += "\n@version: " + __version__
+
+
+# Copyright notice
+__copyright__ = """\
+Copyright (C) 2001-2023 NLTK Project.
+
+Distributed and Licensed under the Apache License, Version 2.0,
+which is included by reference.
+"""
+
+__license__ = "Apache License, Version 2.0"
+# Description of the toolkit, keywords, and the project's primary URL.
+__longdescr__ = """\
+The Natural Language Toolkit (NLTK) is a Python package for
+natural language processing.  NLTK requires Python 3.7, 3.8, 3.9, 3.10 or 3.11."""
+__keywords__ = [
+    "NLP",
+    "CL",
+    "natural language processing",
+    "computational linguistics",
+    "parsing",
+    "tagging",
+    "tokenizing",
+    "syntax",
+    "linguistics",
+    "language",
+    "natural language",
+    "text analytics",
+]
+__url__ = "https://www.nltk.org/"
+
+# Maintainer, contributors, etc.
+__maintainer__ = "NLTK Team"
+__maintainer_email__ = "[email protected]"
+__author__ = __maintainer__
+__author_email__ = __maintainer_email__
+
+# "Trove" classifiers for Python Package Index.
+__classifiers__ = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Education",
+    "Intended Audience :: Information Technology",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: Apache Software License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3.7",
+    "Programming Language :: Python :: 3.8",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Scientific/Engineering",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+    "Topic :: Scientific/Engineering :: Human Machine Interfaces",
+    "Topic :: Scientific/Engineering :: Information Analysis",
+    "Topic :: Text Processing",
+    "Topic :: Text Processing :: Filters",
+    "Topic :: Text Processing :: General",
+    "Topic :: Text Processing :: Indexing",
+    "Topic :: Text Processing :: Linguistic",
+]
+
+from nltk.internals import config_java
+
+# support numpy from pypy
+try:
+    import numpypy
+except ImportError:
+    pass
+
+# Override missing methods on environments where it cannot be used like GAE.
+import subprocess
+
+if not hasattr(subprocess, "PIPE"):
+
+    def _fake_PIPE(*args, **kwargs):
+        raise NotImplementedError("subprocess.PIPE is not supported.")
+
+    subprocess.PIPE = _fake_PIPE
+if not hasattr(subprocess, "Popen"):
+
+    def _fake_Popen(*args, **kwargs):
+        raise NotImplementedError("subprocess.Popen is not supported.")
+
+    subprocess.Popen = _fake_Popen
+
+###########################################################
+# TOP-LEVEL MODULES
+###########################################################
+
+# Import top-level functionality into top-level namespace
+
+from nltk.collocations import *
+from nltk.decorators import decorator, memoize
+from nltk.featstruct import *
+from nltk.grammar import *
+from nltk.probability import *
+from nltk.text import *
+from nltk.util import *
+from nltk.jsontags import *
+
+###########################################################
+# PACKAGES
+###########################################################
+
+from nltk.chunk import *
+from nltk.classify import *
+from nltk.inference import *
+from nltk.metrics import *
+from nltk.parse import *
+from nltk.tag import *
+from nltk.tokenize import *
+from nltk.translate import *
+from nltk.tree import *
+from nltk.sem import *
+from nltk.stem import *
+
+# Packages which can be lazily imported
+# (a) we don't import *
+# (b) they're slow to import or have run-time dependencies
+#     that can safely fail at run time
+
+from nltk import lazyimport
+
+app = lazyimport.LazyModule("app", locals(), globals())
+chat = lazyimport.LazyModule("chat", locals(), globals())
+corpus = lazyimport.LazyModule("corpus", locals(), globals())
+draw = lazyimport.LazyModule("draw", locals(), globals())
+toolbox = lazyimport.LazyModule("toolbox", locals(), globals())
+
+# Optional loading
+
+try:
+    import numpy
+except ImportError:
+    pass
+else:
+    from nltk import cluster
+
+from nltk.downloader import download, download_shell
+
+try:
+    import tkinter
+except ImportError:
+    pass
+else:
+    try:
+        from nltk.downloader import download_gui
+    except RuntimeError as e:
+        import warnings
+
+        warnings.warn(
+            "Corpus downloader GUI not loaded "
+            "(RuntimeError during import: %s)" % str(e)
+        )
+
+# explicitly import all top-level modules (ensuring
+# they override the same names inadvertently imported
+# from a subpackage)
+
+from nltk import ccg, chunk, classify, collocations
+from nltk import data, featstruct, grammar, help, inference, metrics
+from nltk import misc, parse, probability, sem, stem, wsd
+from nltk import tag, tbl, text, tokenize, translate, tree, util
+
+
+# FIXME:  override any accidentally imported demo, see https://github.com/nltk/nltk/issues/2116
+def demo():
+    print("To run the demo code for a module, type nltk.module.demo()")

llmeval-env/lib/python3.10/site-packages/nltk/book.py

@@ -0,0 +1,213 @@
+# Natural Language Toolkit: Some texts for exploration in chapter 1 of the book
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from nltk.corpus import (
+    genesis,
+    gutenberg,
+    inaugural,
+    nps_chat,
+    treebank,
+    webtext,
+    wordnet,
+)
+from nltk.probability import FreqDist
+from nltk.text import Text
+from nltk.util import bigrams
+
+print("*** Introductory Examples for the NLTK Book ***")
+print("Loading text1, ..., text9 and sent1, ..., sent9")
+print("Type the name of the text or sentence to view it.")
+print("Type: 'texts()' or 'sents()' to list the materials.")
+
+text1 = Text(gutenberg.words("melville-moby_dick.txt"))
+print("text1:", text1.name)
+
+text2 = Text(gutenberg.words("austen-sense.txt"))
+print("text2:", text2.name)
+
+text3 = Text(genesis.words("english-kjv.txt"), name="The Book of Genesis")
+print("text3:", text3.name)
+
+text4 = Text(inaugural.words(), name="Inaugural Address Corpus")
+print("text4:", text4.name)
+
+text5 = Text(nps_chat.words(), name="Chat Corpus")
+print("text5:", text5.name)
+
+text6 = Text(webtext.words("grail.txt"), name="Monty Python and the Holy Grail")
+print("text6:", text6.name)
+
+text7 = Text(treebank.words(), name="Wall Street Journal")
+print("text7:", text7.name)
+
+text8 = Text(webtext.words("singles.txt"), name="Personals Corpus")
+print("text8:", text8.name)
+
+text9 = Text(gutenberg.words("chesterton-thursday.txt"))
+print("text9:", text9.name)
+
+
+def texts():
+    print("text1:", text1.name)
+    print("text2:", text2.name)
+    print("text3:", text3.name)
+    print("text4:", text4.name)
+    print("text5:", text5.name)
+    print("text6:", text6.name)
+    print("text7:", text7.name)
+    print("text8:", text8.name)
+    print("text9:", text9.name)
+
+
+sent1 = ["Call", "me", "Ishmael", "."]
+sent2 = [
+    "The",
+    "family",
+    "of",
+    "Dashwood",
+    "had",
+    "long",
+    "been",
+    "settled",
+    "in",
+    "Sussex",
+    ".",
+]
+sent3 = [
+    "In",
+    "the",
+    "beginning",
+    "God",
+    "created",
+    "the",
+    "heaven",
+    "and",
+    "the",
+    "earth",
+    ".",
+]
+sent4 = [
+    "Fellow",
+    "-",
+    "Citizens",
+    "of",
+    "the",
+    "Senate",
+    "and",
+    "of",
+    "the",
+    "House",
+    "of",
+    "Representatives",
+    ":",
+]
+sent5 = [
+    "I",
+    "have",
+    "a",
+    "problem",
+    "with",
+    "people",
+    "PMing",
+    "me",
+    "to",
+    "lol",
+    "JOIN",
+]
+sent6 = [
+    "SCENE",
+    "1",
+    ":",
+    "[",
+    "wind",
+    "]",
+    "[",
+    "clop",
+    "clop",
+    "clop",
+    "]",
+    "KING",
+    "ARTHUR",
+    ":",
+    "Whoa",
+    "there",
+    "!",
+]
+sent7 = [
+    "Pierre",
+    "Vinken",
+    ",",
+    "61",
+    "years",
+    "old",
+    ",",
+    "will",
+    "join",
+    "the",
+    "board",
+    "as",
+    "a",
+    "nonexecutive",
+    "director",
+    "Nov.",
+    "29",
+    ".",
+]
+sent8 = [
+    "25",
+    "SEXY",
+    "MALE",
+    ",",
+    "seeks",
+    "attrac",
+    "older",
+    "single",
+    "lady",
+    ",",
+    "for",
+    "discreet",
+    "encounters",
+    ".",
+]
+sent9 = [
+    "THE",
+    "suburb",
+    "of",
+    "Saffron",
+    "Park",
+    "lay",
+    "on",
+    "the",
+    "sunset",
+    "side",
+    "of",
+    "London",
+    ",",
+    "as",
+    "red",
+    "and",
+    "ragged",
+    "as",
+    "a",
+    "cloud",
+    "of",
+    "sunset",
+    ".",
+]
+
+
+def sents():
+    print("sent1:", " ".join(sent1))
+    print("sent2:", " ".join(sent2))
+    print("sent3:", " ".join(sent3))
+    print("sent4:", " ".join(sent4))
+    print("sent5:", " ".join(sent5))
+    print("sent6:", " ".join(sent6))
+    print("sent7:", " ".join(sent7))
+    print("sent8:", " ".join(sent8))
+    print("sent9:", " ".join(sent9))

llmeval-env/lib/python3.10/site-packages/nltk/ccg/__init__.py

@@ -0,0 +1,34 @@
+# Natural Language Toolkit: Combinatory Categorial Grammar
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Graeme Gange <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Combinatory Categorial Grammar.
+
+For more information see nltk/doc/contrib/ccg/ccg.pdf
+"""
+
+from nltk.ccg.chart import CCGChart, CCGChartParser, CCGEdge, CCGLeafEdge
+from nltk.ccg.combinator import (
+    BackwardApplication,
+    BackwardBx,
+    BackwardCombinator,
+    BackwardComposition,
+    BackwardSx,
+    BackwardT,
+    DirectedBinaryCombinator,
+    ForwardApplication,
+    ForwardCombinator,
+    ForwardComposition,
+    ForwardSubstitution,
+    ForwardT,
+    UndirectedBinaryCombinator,
+    UndirectedComposition,
+    UndirectedFunctionApplication,
+    UndirectedSubstitution,
+    UndirectedTypeRaise,
+)
+from nltk.ccg.lexicon import CCGLexicon

llmeval-env/lib/python3.10/site-packages/nltk/ccg/api.py

@@ -0,0 +1,358 @@
+# Natural Language Toolkit: CCG Categories
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Graeme Gange <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from abc import ABCMeta, abstractmethod
+from functools import total_ordering
+
+from nltk.internals import raise_unorderable_types
+
+
+@total_ordering
+class AbstractCCGCategory(metaclass=ABCMeta):
+    """
+    Interface for categories in combinatory grammars.
+    """
+
+    @abstractmethod
+    def is_primitive(self):
+        """
+        Returns true if the category is primitive.
+        """
+
+    @abstractmethod
+    def is_function(self):
+        """
+        Returns true if the category is a function application.
+        """
+
+    @abstractmethod
+    def is_var(self):
+        """
+        Returns true if the category is a variable.
+        """
+
+    @abstractmethod
+    def substitute(self, substitutions):
+        """
+        Takes a set of (var, category) substitutions, and replaces every
+        occurrence of the variable with the corresponding category.
+        """
+
+    @abstractmethod
+    def can_unify(self, other):
+        """
+        Determines whether two categories can be unified.
+         - Returns None if they cannot be unified
+         - Returns a list of necessary substitutions if they can.
+        """
+
+    # Utility functions: comparison, strings and hashing.
+    @abstractmethod
+    def __str__(self):
+        pass
+
+    def __eq__(self, other):
+        return (
+            self.__class__ is other.__class__
+            and self._comparison_key == other._comparison_key
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, AbstractCCGCategory):
+            raise_unorderable_types("<", self, other)
+        if self.__class__ is other.__class__:
+            return self._comparison_key < other._comparison_key
+        else:
+            return self.__class__.__name__ < other.__class__.__name__
+
+    def __hash__(self):
+        try:
+            return self._hash
+        except AttributeError:
+            self._hash = hash(self._comparison_key)
+            return self._hash
+
+
+class CCGVar(AbstractCCGCategory):
+    """
+    Class representing a variable CCG category.
+    Used for conjunctions (and possibly type-raising, if implemented as a
+    unary rule).
+    """
+
+    _maxID = 0
+
+    def __init__(self, prim_only=False):
+        """Initialize a variable (selects a new identifier)
+
+        :param prim_only: a boolean that determines whether the variable is
+                          restricted to primitives
+        :type prim_only: bool
+        """
+        self._id = self.new_id()
+        self._prim_only = prim_only
+        self._comparison_key = self._id
+
+    @classmethod
+    def new_id(cls):
+        """
+        A class method allowing generation of unique variable identifiers.
+        """
+        cls._maxID = cls._maxID + 1
+        return cls._maxID - 1
+
+    @classmethod
+    def reset_id(cls):
+        cls._maxID = 0
+
+    def is_primitive(self):
+        return False
+
+    def is_function(self):
+        return False
+
+    def is_var(self):
+        return True
+
+    def substitute(self, substitutions):
+        """If there is a substitution corresponding to this variable,
+        return the substituted category.
+        """
+        for (var, cat) in substitutions:
+            if var == self:
+                return cat
+        return self
+
+    def can_unify(self, other):
+        """If the variable can be replaced with other
+        a substitution is returned.
+        """
+        if other.is_primitive() or not self._prim_only:
+            return [(self, other)]
+        return None
+
+    def id(self):
+        return self._id
+
+    def __str__(self):
+        return "_var" + str(self._id)
+
+
+@total_ordering
+class Direction:
+    """
+    Class representing the direction of a function application.
+    Also contains maintains information as to which combinators
+    may be used with the category.
+    """
+
+    def __init__(self, dir, restrictions):
+        self._dir = dir
+        self._restrs = restrictions
+        self._comparison_key = (dir, tuple(restrictions))
+
+    # Testing the application direction
+    def is_forward(self):
+        return self._dir == "/"
+
+    def is_backward(self):
+        return self._dir == "\\"
+
+    def dir(self):
+        return self._dir
+
+    def restrs(self):
+        """A list of restrictions on the combinators.
+        '.' denotes that permuting operations are disallowed
+        ',' denotes that function composition is disallowed
+        '_' denotes that the direction has variable restrictions.
+        (This is redundant in the current implementation of type-raising)
+        """
+        return self._restrs
+
+    def is_variable(self):
+        return self._restrs == "_"
+
+    # Unification and substitution of variable directions.
+    # Used only if type-raising is implemented as a unary rule, as it
+    # must inherit restrictions from the argument category.
+    def can_unify(self, other):
+        if other.is_variable():
+            return [("_", self.restrs())]
+        elif self.is_variable():
+            return [("_", other.restrs())]
+        else:
+            if self.restrs() == other.restrs():
+                return []
+        return None
+
+    def substitute(self, subs):
+        if not self.is_variable():
+            return self
+
+        for (var, restrs) in subs:
+            if var == "_":
+                return Direction(self._dir, restrs)
+        return self
+
+    # Testing permitted combinators
+    def can_compose(self):
+        return "," not in self._restrs
+
+    def can_cross(self):
+        return "." not in self._restrs
+
+    def __eq__(self, other):
+        return (
+            self.__class__ is other.__class__
+            and self._comparison_key == other._comparison_key
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, Direction):
+            raise_unorderable_types("<", self, other)
+        if self.__class__ is other.__class__:
+            return self._comparison_key < other._comparison_key
+        else:
+            return self.__class__.__name__ < other.__class__.__name__
+
+    def __hash__(self):
+        try:
+            return self._hash
+        except AttributeError:
+            self._hash = hash(self._comparison_key)
+            return self._hash
+
+    def __str__(self):
+        r_str = ""
+        for r in self._restrs:
+            r_str = r_str + "%s" % r
+        return f"{self._dir}{r_str}"
+
+    # The negation operator reverses the direction of the application
+    def __neg__(self):
+        if self._dir == "/":
+            return Direction("\\", self._restrs)
+        else:
+            return Direction("/", self._restrs)
+
+
+class PrimitiveCategory(AbstractCCGCategory):
+    """
+    Class representing primitive categories.
+    Takes a string representation of the category, and a
+    list of strings specifying the morphological subcategories.
+    """
+
+    def __init__(self, categ, restrictions=[]):
+        self._categ = categ
+        self._restrs = restrictions
+        self._comparison_key = (categ, tuple(restrictions))
+
+    def is_primitive(self):
+        return True
+
+    def is_function(self):
+        return False
+
+    def is_var(self):
+        return False
+
+    def restrs(self):
+        return self._restrs
+
+    def categ(self):
+        return self._categ
+
+    # Substitution does nothing to a primitive category
+    def substitute(self, subs):
+        return self
+
+    # A primitive can be unified with a class of the same
+    # base category, given that the other category shares all
+    # of its subclasses, or with a variable.
+    def can_unify(self, other):
+        if not other.is_primitive():
+            return None
+        if other.is_var():
+            return [(other, self)]
+        if other.categ() == self.categ():
+            for restr in self._restrs:
+                if restr not in other.restrs():
+                    return None
+            return []
+        return None
+
+    def __str__(self):
+        if self._restrs == []:
+            return "%s" % self._categ
+        restrictions = "[%s]" % ",".join(repr(r) for r in self._restrs)
+        return f"{self._categ}{restrictions}"
+
+
+class FunctionalCategory(AbstractCCGCategory):
+    """
+    Class that represents a function application category.
+    Consists of argument and result categories, together with
+    an application direction.
+    """
+
+    def __init__(self, res, arg, dir):
+        self._res = res
+        self._arg = arg
+        self._dir = dir
+        self._comparison_key = (arg, dir, res)
+
+    def is_primitive(self):
+        return False
+
+    def is_function(self):
+        return True
+
+    def is_var(self):
+        return False
+
+    # Substitution returns the category consisting of the
+    # substitution applied to each of its constituents.
+    def substitute(self, subs):
+        sub_res = self._res.substitute(subs)
+        sub_dir = self._dir.substitute(subs)
+        sub_arg = self._arg.substitute(subs)
+        return FunctionalCategory(sub_res, sub_arg, self._dir)
+
+    # A function can unify with another function, so long as its
+    # constituents can unify, or with an unrestricted variable.
+    def can_unify(self, other):
+        if other.is_var():
+            return [(other, self)]
+        if other.is_function():
+            sa = self._res.can_unify(other.res())
+            sd = self._dir.can_unify(other.dir())
+            if sa is not None and sd is not None:
+                sb = self._arg.substitute(sa).can_unify(other.arg().substitute(sa))
+                if sb is not None:
+                    return sa + sb
+        return None
+
+    # Constituent accessors
+    def arg(self):
+        return self._arg
+
+    def res(self):
+        return self._res
+
+    def dir(self):
+        return self._dir
+
+    def __str__(self):
+        return f"({self._res}{self._dir}{self._arg})"

llmeval-env/lib/python3.10/site-packages/nltk/ccg/chart.py

@@ -0,0 +1,480 @@
+# Natural Language Toolkit: Combinatory Categorial Grammar
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Graeme Gange <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+The lexicon is constructed by calling
+``lexicon.fromstring(<lexicon string>)``.
+
+In order to construct a parser, you also need a rule set.
+The standard English rules are provided in chart as
+``chart.DefaultRuleSet``.
+
+The parser can then be constructed by calling, for example:
+``parser = chart.CCGChartParser(<lexicon>, <ruleset>)``
+
+Parsing is then performed by running
+``parser.parse(<sentence>.split())``.
+
+While this returns a list of trees, the default representation
+of the produced trees is not very enlightening, particularly
+given that it uses the same tree class as the CFG parsers.
+It is probably better to call:
+``chart.printCCGDerivation(<parse tree extracted from list>)``
+which should print a nice representation of the derivation.
+
+This entire process is shown far more clearly in the demonstration:
+python chart.py
+"""
+
+import itertools
+
+from nltk.ccg.combinator import *
+from nltk.ccg.combinator import (
+    BackwardApplication,
+    BackwardBx,
+    BackwardComposition,
+    BackwardSx,
+    BackwardT,
+    ForwardApplication,
+    ForwardComposition,
+    ForwardSubstitution,
+    ForwardT,
+)
+from nltk.ccg.lexicon import Token, fromstring
+from nltk.ccg.logic import *
+from nltk.parse import ParserI
+from nltk.parse.chart import AbstractChartRule, Chart, EdgeI
+from nltk.sem.logic import *
+from nltk.tree import Tree
+
+
+# Based on the EdgeI class from NLTK.
+# A number of the properties of the EdgeI interface don't
+# transfer well to CCGs, however.
+class CCGEdge(EdgeI):
+    def __init__(self, span, categ, rule):
+        self._span = span
+        self._categ = categ
+        self._rule = rule
+        self._comparison_key = (span, categ, rule)
+
+    # Accessors
+    def lhs(self):
+        return self._categ
+
+    def span(self):
+        return self._span
+
+    def start(self):
+        return self._span[0]
+
+    def end(self):
+        return self._span[1]
+
+    def length(self):
+        return self._span[1] - self.span[0]
+
+    def rhs(self):
+        return ()
+
+    def dot(self):
+        return 0
+
+    def is_complete(self):
+        return True
+
+    def is_incomplete(self):
+        return False
+
+    def nextsym(self):
+        return None
+
+    def categ(self):
+        return self._categ
+
+    def rule(self):
+        return self._rule
+
+
+class CCGLeafEdge(EdgeI):
+    """
+    Class representing leaf edges in a CCG derivation.
+    """
+
+    def __init__(self, pos, token, leaf):
+        self._pos = pos
+        self._token = token
+        self._leaf = leaf
+        self._comparison_key = (pos, token.categ(), leaf)
+
+    # Accessors
+    def lhs(self):
+        return self._token.categ()
+
+    def span(self):
+        return (self._pos, self._pos + 1)
+
+    def start(self):
+        return self._pos
+
+    def end(self):
+        return self._pos + 1
+
+    def length(self):
+        return 1
+
+    def rhs(self):
+        return self._leaf
+
+    def dot(self):
+        return 0
+
+    def is_complete(self):
+        return True
+
+    def is_incomplete(self):
+        return False
+
+    def nextsym(self):
+        return None
+
+    def token(self):
+        return self._token
+
+    def categ(self):
+        return self._token.categ()
+
+    def leaf(self):
+        return self._leaf
+
+
+class BinaryCombinatorRule(AbstractChartRule):
+    """
+    Class implementing application of a binary combinator to a chart.
+    Takes the directed combinator to apply.
+    """
+
+    NUMEDGES = 2
+
+    def __init__(self, combinator):
+        self._combinator = combinator
+
+    # Apply a combinator
+    def apply(self, chart, grammar, left_edge, right_edge):
+        # The left & right edges must be touching.
+        if not (left_edge.end() == right_edge.start()):
+            return
+
+        # Check if the two edges are permitted to combine.
+        # If so, generate the corresponding edge.
+        if self._combinator.can_combine(left_edge.categ(), right_edge.categ()):
+            for res in self._combinator.combine(left_edge.categ(), right_edge.categ()):
+                new_edge = CCGEdge(
+                    span=(left_edge.start(), right_edge.end()),
+                    categ=res,
+                    rule=self._combinator,
+                )
+                if chart.insert(new_edge, (left_edge, right_edge)):
+                    yield new_edge
+
+    # The representation of the combinator (for printing derivations)
+    def __str__(self):
+        return "%s" % self._combinator
+
+
+# Type-raising must be handled slightly differently to the other rules, as the
+# resulting rules only span a single edge, rather than both edges.
+
+
+class ForwardTypeRaiseRule(AbstractChartRule):
+    """
+    Class for applying forward type raising
+    """
+
+    NUMEDGES = 2
+
+    def __init__(self):
+        self._combinator = ForwardT
+
+    def apply(self, chart, grammar, left_edge, right_edge):
+        if not (left_edge.end() == right_edge.start()):
+            return
+
+        for res in self._combinator.combine(left_edge.categ(), right_edge.categ()):
+            new_edge = CCGEdge(span=left_edge.span(), categ=res, rule=self._combinator)
+            if chart.insert(new_edge, (left_edge,)):
+                yield new_edge
+
+    def __str__(self):
+        return "%s" % self._combinator
+
+
+class BackwardTypeRaiseRule(AbstractChartRule):
+    """
+    Class for applying backward type raising.
+    """
+
+    NUMEDGES = 2
+
+    def __init__(self):
+        self._combinator = BackwardT
+
+    def apply(self, chart, grammar, left_edge, right_edge):
+        if not (left_edge.end() == right_edge.start()):
+            return
+
+        for res in self._combinator.combine(left_edge.categ(), right_edge.categ()):
+            new_edge = CCGEdge(span=right_edge.span(), categ=res, rule=self._combinator)
+            if chart.insert(new_edge, (right_edge,)):
+                yield new_edge
+
+    def __str__(self):
+        return "%s" % self._combinator
+
+
+# Common sets of combinators used for English derivations.
+ApplicationRuleSet = [
+    BinaryCombinatorRule(ForwardApplication),
+    BinaryCombinatorRule(BackwardApplication),
+]
+CompositionRuleSet = [
+    BinaryCombinatorRule(ForwardComposition),
+    BinaryCombinatorRule(BackwardComposition),
+    BinaryCombinatorRule(BackwardBx),
+]
+SubstitutionRuleSet = [
+    BinaryCombinatorRule(ForwardSubstitution),
+    BinaryCombinatorRule(BackwardSx),
+]
+TypeRaiseRuleSet = [ForwardTypeRaiseRule(), BackwardTypeRaiseRule()]
+
+# The standard English rule set.
+DefaultRuleSet = (
+    ApplicationRuleSet + CompositionRuleSet + SubstitutionRuleSet + TypeRaiseRuleSet
+)
+
+
+class CCGChartParser(ParserI):
+    """
+    Chart parser for CCGs.
+    Based largely on the ChartParser class from NLTK.
+    """
+
+    def __init__(self, lexicon, rules, trace=0):
+        self._lexicon = lexicon
+        self._rules = rules
+        self._trace = trace
+
+    def lexicon(self):
+        return self._lexicon
+
+    # Implements the CYK algorithm
+    def parse(self, tokens):
+        tokens = list(tokens)
+        chart = CCGChart(list(tokens))
+        lex = self._lexicon
+
+        # Initialize leaf edges.
+        for index in range(chart.num_leaves()):
+            for token in lex.categories(chart.leaf(index)):
+                new_edge = CCGLeafEdge(index, token, chart.leaf(index))
+                chart.insert(new_edge, ())
+
+        # Select a span for the new edges
+        for span in range(2, chart.num_leaves() + 1):
+            for start in range(0, chart.num_leaves() - span + 1):
+                # Try all possible pairs of edges that could generate
+                # an edge for that span
+                for part in range(1, span):
+                    lstart = start
+                    mid = start + part
+                    rend = start + span
+
+                    for left in chart.select(span=(lstart, mid)):
+                        for right in chart.select(span=(mid, rend)):
+                            # Generate all possible combinations of the two edges
+                            for rule in self._rules:
+                                edges_added_by_rule = 0
+                                for newedge in rule.apply(chart, lex, left, right):
+                                    edges_added_by_rule += 1
+
+        # Output the resulting parses
+        return chart.parses(lex.start())
+
+
+class CCGChart(Chart):
+    def __init__(self, tokens):
+        Chart.__init__(self, tokens)
+
+    # Constructs the trees for a given parse. Unfortnunately, the parse trees need to be
+    # constructed slightly differently to those in the default Chart class, so it has to
+    # be reimplemented
+    def _trees(self, edge, complete, memo, tree_class):
+        assert complete, "CCGChart cannot build incomplete trees"
+
+        if edge in memo:
+            return memo[edge]
+
+        if isinstance(edge, CCGLeafEdge):
+            word = tree_class(edge.token(), [self._tokens[edge.start()]])
+            leaf = tree_class((edge.token(), "Leaf"), [word])
+            memo[edge] = [leaf]
+            return [leaf]
+
+        memo[edge] = []
+        trees = []
+
+        for cpl in self.child_pointer_lists(edge):
+            child_choices = [self._trees(cp, complete, memo, tree_class) for cp in cpl]
+            for children in itertools.product(*child_choices):
+                lhs = (
+                    Token(
+                        self._tokens[edge.start() : edge.end()],
+                        edge.lhs(),
+                        compute_semantics(children, edge),
+                    ),
+                    str(edge.rule()),
+                )
+                trees.append(tree_class(lhs, children))
+
+        memo[edge] = trees
+        return trees
+
+
+def compute_semantics(children, edge):
+    if children[0].label()[0].semantics() is None:
+        return None
+
+    if len(children) == 2:
+        if isinstance(edge.rule(), BackwardCombinator):
+            children = [children[1], children[0]]
+
+        combinator = edge.rule()._combinator
+        function = children[0].label()[0].semantics()
+        argument = children[1].label()[0].semantics()
+
+        if isinstance(combinator, UndirectedFunctionApplication):
+            return compute_function_semantics(function, argument)
+        elif isinstance(combinator, UndirectedComposition):
+            return compute_composition_semantics(function, argument)
+        elif isinstance(combinator, UndirectedSubstitution):
+            return compute_substitution_semantics(function, argument)
+        else:
+            raise AssertionError("Unsupported combinator '" + combinator + "'")
+    else:
+        return compute_type_raised_semantics(children[0].label()[0].semantics())
+
+
+# --------
+# Displaying derivations
+# --------
+def printCCGDerivation(tree):
+    # Get the leaves and initial categories
+    leafcats = tree.pos()
+    leafstr = ""
+    catstr = ""
+
+    # Construct a string with both the leaf word and corresponding
+    # category aligned.
+    for (leaf, cat) in leafcats:
+        str_cat = "%s" % cat
+        nextlen = 2 + max(len(leaf), len(str_cat))
+        lcatlen = (nextlen - len(str_cat)) // 2
+        rcatlen = lcatlen + (nextlen - len(str_cat)) % 2
+        catstr += " " * lcatlen + str_cat + " " * rcatlen
+        lleaflen = (nextlen - len(leaf)) // 2
+        rleaflen = lleaflen + (nextlen - len(leaf)) % 2
+        leafstr += " " * lleaflen + leaf + " " * rleaflen
+    print(leafstr.rstrip())
+    print(catstr.rstrip())
+
+    # Display the derivation steps
+    printCCGTree(0, tree)
+
+
+# Prints the sequence of derivation steps.
+def printCCGTree(lwidth, tree):
+    rwidth = lwidth
+
+    # Is a leaf (word).
+    # Increment the span by the space occupied by the leaf.
+    if not isinstance(tree, Tree):
+        return 2 + lwidth + len(tree)
+
+    # Find the width of the current derivation step
+    for child in tree:
+        rwidth = max(rwidth, printCCGTree(rwidth, child))
+
+    # Is a leaf node.
+    # Don't print anything, but account for the space occupied.
+    if not isinstance(tree.label(), tuple):
+        return max(
+            rwidth, 2 + lwidth + len("%s" % tree.label()), 2 + lwidth + len(tree[0])
+        )
+
+    (token, op) = tree.label()
+
+    if op == "Leaf":
+        return rwidth
+
+    # Pad to the left with spaces, followed by a sequence of '-'
+    # and the derivation rule.
+    print(lwidth * " " + (rwidth - lwidth) * "-" + "%s" % op)
+    # Print the resulting category on a new line.
+    str_res = "%s" % (token.categ())
+    if token.semantics() is not None:
+        str_res += " {" + str(token.semantics()) + "}"
+    respadlen = (rwidth - lwidth - len(str_res)) // 2 + lwidth
+    print(respadlen * " " + str_res)
+    return rwidth
+
+
+### Demonstration code
+
+# Construct the lexicon
+lex = fromstring(
+    """
+    :- S, NP, N, VP    # Primitive categories, S is the target primitive
+
+    Det :: NP/N         # Family of words
+    Pro :: NP
+    TV :: VP/NP
+    Modal :: (S\\NP)/VP # Backslashes need to be escaped
+
+    I => Pro             # Word -> Category mapping
+    you => Pro
+
+    the => Det
+
+    # Variables have the special keyword 'var'
+    # '.' prevents permutation
+    # ',' prevents composition
+    and => var\\.,var/.,var
+
+    which => (N\\N)/(S/NP)
+
+    will => Modal # Categories can be either explicit, or families.
+    might => Modal
+
+    cook => TV
+    eat => TV
+
+    mushrooms => N
+    parsnips => N
+    bacon => N
+    """
+)
+
+
+def demo():
+    parser = CCGChartParser(lex, DefaultRuleSet)
+    for parse in parser.parse("I might cook and eat the bacon".split()):
+        printCCGDerivation(parse)
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/ccg/combinator.py

@@ -0,0 +1,339 @@
+# Natural Language Toolkit: Combinatory Categorial Grammar
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Graeme Gange <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+"""
+CCG Combinators
+"""
+
+from abc import ABCMeta, abstractmethod
+
+from nltk.ccg.api import FunctionalCategory
+
+
+class UndirectedBinaryCombinator(metaclass=ABCMeta):
+    """
+    Abstract class for representing a binary combinator.
+    Merely defines functions for checking if the function and argument
+    are able to be combined, and what the resulting category is.
+
+    Note that as no assumptions are made as to direction, the unrestricted
+    combinators can perform all backward, forward and crossed variations
+    of the combinators; these restrictions must be added in the rule
+    class.
+    """
+
+    @abstractmethod
+    def can_combine(self, function, argument):
+        pass
+
+    @abstractmethod
+    def combine(self, function, argument):
+        pass
+
+
+class DirectedBinaryCombinator(metaclass=ABCMeta):
+    """
+    Wrapper for the undirected binary combinator.
+    It takes left and right categories, and decides which is to be
+    the function, and which the argument.
+    It then decides whether or not they can be combined.
+    """
+
+    @abstractmethod
+    def can_combine(self, left, right):
+        pass
+
+    @abstractmethod
+    def combine(self, left, right):
+        pass
+
+
+class ForwardCombinator(DirectedBinaryCombinator):
+    """
+    Class representing combinators where the primary functor is on the left.
+
+    Takes an undirected combinator, and a predicate which adds constraints
+    restricting the cases in which it may apply.
+    """
+
+    def __init__(self, combinator, predicate, suffix=""):
+        self._combinator = combinator
+        self._predicate = predicate
+        self._suffix = suffix
+
+    def can_combine(self, left, right):
+        return self._combinator.can_combine(left, right) and self._predicate(
+            left, right
+        )
+
+    def combine(self, left, right):
+        yield from self._combinator.combine(left, right)
+
+    def __str__(self):
+        return f">{self._combinator}{self._suffix}"
+
+
+class BackwardCombinator(DirectedBinaryCombinator):
+    """
+    The backward equivalent of the ForwardCombinator class.
+    """
+
+    def __init__(self, combinator, predicate, suffix=""):
+        self._combinator = combinator
+        self._predicate = predicate
+        self._suffix = suffix
+
+    def can_combine(self, left, right):
+        return self._combinator.can_combine(right, left) and self._predicate(
+            left, right
+        )
+
+    def combine(self, left, right):
+        yield from self._combinator.combine(right, left)
+
+    def __str__(self):
+        return f"<{self._combinator}{self._suffix}"
+
+
+class UndirectedFunctionApplication(UndirectedBinaryCombinator):
+    """
+    Class representing function application.
+    Implements rules of the form:
+    X/Y Y -> X (>)
+    And the corresponding backwards application rule
+    """
+
+    def can_combine(self, function, argument):
+        if not function.is_function():
+            return False
+
+        return not function.arg().can_unify(argument) is None
+
+    def combine(self, function, argument):
+        if not function.is_function():
+            return
+
+        subs = function.arg().can_unify(argument)
+        if subs is None:
+            return
+
+        yield function.res().substitute(subs)
+
+    def __str__(self):
+        return ""
+
+
+# Predicates for function application.
+
+# Ensures the left functor takes an argument on the right
+def forwardOnly(left, right):
+    return left.dir().is_forward()
+
+
+# Ensures the right functor takes an argument on the left
+def backwardOnly(left, right):
+    return right.dir().is_backward()
+
+
+# Application combinator instances
+ForwardApplication = ForwardCombinator(UndirectedFunctionApplication(), forwardOnly)
+BackwardApplication = BackwardCombinator(UndirectedFunctionApplication(), backwardOnly)
+
+
+class UndirectedComposition(UndirectedBinaryCombinator):
+    """
+    Functional composition (harmonic) combinator.
+    Implements rules of the form
+    X/Y Y/Z -> X/Z (B>)
+    And the corresponding backwards and crossed variations.
+    """
+
+    def can_combine(self, function, argument):
+        # Can only combine two functions, and both functions must
+        # allow composition.
+        if not (function.is_function() and argument.is_function()):
+            return False
+        if function.dir().can_compose() and argument.dir().can_compose():
+            return not function.arg().can_unify(argument.res()) is None
+        return False
+
+    def combine(self, function, argument):
+        if not (function.is_function() and argument.is_function()):
+            return
+        if function.dir().can_compose() and argument.dir().can_compose():
+            subs = function.arg().can_unify(argument.res())
+            if subs is not None:
+                yield FunctionalCategory(
+                    function.res().substitute(subs),
+                    argument.arg().substitute(subs),
+                    argument.dir(),
+                )
+
+    def __str__(self):
+        return "B"
+
+
+# Predicates for restricting application of straight composition.
+def bothForward(left, right):
+    return left.dir().is_forward() and right.dir().is_forward()
+
+
+def bothBackward(left, right):
+    return left.dir().is_backward() and right.dir().is_backward()
+
+
+# Predicates for crossed composition
+def crossedDirs(left, right):
+    return left.dir().is_forward() and right.dir().is_backward()
+
+
+def backwardBxConstraint(left, right):
+    # The functors must be crossed inwards
+    if not crossedDirs(left, right):
+        return False
+    # Permuting combinators must be allowed
+    if not left.dir().can_cross() and right.dir().can_cross():
+        return False
+    # The resulting argument category is restricted to be primitive
+    return left.arg().is_primitive()
+
+
+# Straight composition combinators
+ForwardComposition = ForwardCombinator(UndirectedComposition(), forwardOnly)
+BackwardComposition = BackwardCombinator(UndirectedComposition(), backwardOnly)
+
+# Backward crossed composition
+BackwardBx = BackwardCombinator(
+    UndirectedComposition(), backwardBxConstraint, suffix="x"
+)
+
+
+class UndirectedSubstitution(UndirectedBinaryCombinator):
+    r"""
+    Substitution (permutation) combinator.
+    Implements rules of the form
+    Y/Z (X\Y)/Z -> X/Z (<Sx)
+    And other variations.
+    """
+
+    def can_combine(self, function, argument):
+        if function.is_primitive() or argument.is_primitive():
+            return False
+
+        # These could potentially be moved to the predicates, as the
+        # constraints may not be general to all languages.
+        if function.res().is_primitive():
+            return False
+        if not function.arg().is_primitive():
+            return False
+
+        if not (function.dir().can_compose() and argument.dir().can_compose()):
+            return False
+        return (function.res().arg() == argument.res()) and (
+            function.arg() == argument.arg()
+        )
+
+    def combine(self, function, argument):
+        if self.can_combine(function, argument):
+            yield FunctionalCategory(
+                function.res().res(), argument.arg(), argument.dir()
+            )
+
+    def __str__(self):
+        return "S"
+
+
+# Predicate for forward substitution
+def forwardSConstraint(left, right):
+    if not bothForward(left, right):
+        return False
+    return left.res().dir().is_forward() and left.arg().is_primitive()
+
+
+# Predicate for backward crossed substitution
+def backwardSxConstraint(left, right):
+    if not left.dir().can_cross() and right.dir().can_cross():
+        return False
+    if not bothForward(left, right):
+        return False
+    return right.res().dir().is_backward() and right.arg().is_primitive()
+
+
+# Instances of substitution combinators
+ForwardSubstitution = ForwardCombinator(UndirectedSubstitution(), forwardSConstraint)
+BackwardSx = BackwardCombinator(UndirectedSubstitution(), backwardSxConstraint, "x")
+
+
+# Retrieves the left-most functional category.
+# ie, (N\N)/(S/NP) => N\N
+def innermostFunction(categ):
+    while categ.res().is_function():
+        categ = categ.res()
+    return categ
+
+
+class UndirectedTypeRaise(UndirectedBinaryCombinator):
+    """
+    Undirected combinator for type raising.
+    """
+
+    def can_combine(self, function, arg):
+        # The argument must be a function.
+        # The restriction that arg.res() must be a function
+        # merely reduces redundant type-raising; if arg.res() is
+        # primitive, we have:
+        # X Y\X =>(<T) Y/(Y\X) Y\X =>(>) Y
+        # which is equivalent to
+        # X Y\X =>(<) Y
+        if not (arg.is_function() and arg.res().is_function()):
+            return False
+
+        arg = innermostFunction(arg)
+
+        # left, arg_categ are undefined!
+        subs = left.can_unify(arg_categ.arg())
+        if subs is not None:
+            return True
+        return False
+
+    def combine(self, function, arg):
+        if not (
+            function.is_primitive() and arg.is_function() and arg.res().is_function()
+        ):
+            return
+
+        # Type-raising matches only the innermost application.
+        arg = innermostFunction(arg)
+
+        subs = function.can_unify(arg.arg())
+        if subs is not None:
+            xcat = arg.res().substitute(subs)
+            yield FunctionalCategory(
+                xcat, FunctionalCategory(xcat, function, arg.dir()), -(arg.dir())
+            )
+
+    def __str__(self):
+        return "T"
+
+
+# Predicates for type-raising
+# The direction of the innermost category must be towards
+# the primary functor.
+# The restriction that the variable must be primitive is not
+# common to all versions of CCGs; some authors have other restrictions.
+def forwardTConstraint(left, right):
+    arg = innermostFunction(right)
+    return arg.dir().is_backward() and arg.res().is_primitive()
+
+
+def backwardTConstraint(left, right):
+    arg = innermostFunction(left)
+    return arg.dir().is_forward() and arg.res().is_primitive()
+
+
+# Instances of type-raising combinators
+ForwardT = ForwardCombinator(UndirectedTypeRaise(), forwardTConstraint)
+BackwardT = BackwardCombinator(UndirectedTypeRaise(), backwardTConstraint)

llmeval-env/lib/python3.10/site-packages/nltk/ccg/logic.py

@@ -0,0 +1,60 @@
+# Natural Language Toolkit: Combinatory Categorial Grammar
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Tanin Na Nakorn (@tanin)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+"""
+Helper functions for CCG semantics computation
+"""
+
+from nltk.sem.logic import *
+
+
+def compute_type_raised_semantics(semantics):
+    core = semantics
+    parent = None
+    while isinstance(core, LambdaExpression):
+        parent = core
+        core = core.term
+
+    var = Variable("F")
+    while var in core.free():
+        var = unique_variable(pattern=var)
+    core = ApplicationExpression(FunctionVariableExpression(var), core)
+
+    if parent is not None:
+        parent.term = core
+    else:
+        semantics = core
+
+    return LambdaExpression(var, semantics)
+
+
+def compute_function_semantics(function, argument):
+    return ApplicationExpression(function, argument).simplify()
+
+
+def compute_composition_semantics(function, argument):
+    assert isinstance(argument, LambdaExpression), (
+        "`" + str(argument) + "` must be a lambda expression"
+    )
+    return LambdaExpression(
+        argument.variable, ApplicationExpression(function, argument.term).simplify()
+    )
+
+
+def compute_substitution_semantics(function, argument):
+    assert isinstance(function, LambdaExpression) and isinstance(
+        function.term, LambdaExpression
+    ), ("`" + str(function) + "` must be a lambda expression with 2 arguments")
+    assert isinstance(argument, LambdaExpression), (
+        "`" + str(argument) + "` must be a lambda expression"
+    )
+
+    new_argument = ApplicationExpression(
+        argument, VariableExpression(function.variable)
+    ).simplify()
+    new_term = ApplicationExpression(function.term, new_argument).simplify()
+
+    return LambdaExpression(function.variable, new_term)

llmeval-env/lib/python3.10/site-packages/nltk/chunk/__init__.py

@@ -0,0 +1,197 @@
+# Natural Language Toolkit: Chunkers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+#         Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+"""
+Classes and interfaces for identifying non-overlapping linguistic
+groups (such as base noun phrases) in unrestricted text.  This task is
+called "chunk parsing" or "chunking", and the identified groups are
+called "chunks".  The chunked text is represented using a shallow
+tree called a "chunk structure."  A chunk structure is a tree
+containing tokens and chunks, where each chunk is a subtree containing
+only tokens.  For example, the chunk structure for base noun phrase
+chunks in the sentence "I saw the big dog on the hill" is::
+
+  (SENTENCE:
+    (NP: <I>)
+    <saw>
+    (NP: <the> <big> <dog>)
+    <on>
+    (NP: <the> <hill>))
+
+To convert a chunk structure back to a list of tokens, simply use the
+chunk structure's ``leaves()`` method.
+
+This module defines ``ChunkParserI``, a standard interface for
+chunking texts; and ``RegexpChunkParser``, a regular-expression based
+implementation of that interface. It also defines ``ChunkScore``, a
+utility class for scoring chunk parsers.
+
+RegexpChunkParser
+=================
+
+``RegexpChunkParser`` is an implementation of the chunk parser interface
+that uses regular-expressions over tags to chunk a text.  Its
+``parse()`` method first constructs a ``ChunkString``, which encodes a
+particular chunking of the input text.  Initially, nothing is
+chunked.  ``parse.RegexpChunkParser`` then applies a sequence of
+``RegexpChunkRule`` rules to the ``ChunkString``, each of which modifies
+the chunking that it encodes.  Finally, the ``ChunkString`` is
+transformed back into a chunk structure, which is returned.
+
+``RegexpChunkParser`` can only be used to chunk a single kind of phrase.
+For example, you can use an ``RegexpChunkParser`` to chunk the noun
+phrases in a text, or the verb phrases in a text; but you can not
+use it to simultaneously chunk both noun phrases and verb phrases in
+the same text.  (This is a limitation of ``RegexpChunkParser``, not of
+chunk parsers in general.)
+
+RegexpChunkRules
+----------------
+
+A ``RegexpChunkRule`` is a transformational rule that updates the
+chunking of a text by modifying its ``ChunkString``.  Each
+``RegexpChunkRule`` defines the ``apply()`` method, which modifies
+the chunking encoded by a ``ChunkString``.  The
+``RegexpChunkRule`` class itself can be used to implement any
+transformational rule based on regular expressions.  There are
+also a number of subclasses, which can be used to implement
+simpler types of rules:
+
+    - ``ChunkRule`` chunks anything that matches a given regular
+      expression.
+    - ``StripRule`` strips anything that matches a given regular
+      expression.
+    - ``UnChunkRule`` will un-chunk any chunk that matches a given
+      regular expression.
+    - ``MergeRule`` can be used to merge two contiguous chunks.
+    - ``SplitRule`` can be used to split a single chunk into two
+      smaller chunks.
+    - ``ExpandLeftRule`` will expand a chunk to incorporate new
+      unchunked material on the left.
+    - ``ExpandRightRule`` will expand a chunk to incorporate new
+      unchunked material on the right.
+
+Tag Patterns
+~~~~~~~~~~~~
+
+A ``RegexpChunkRule`` uses a modified version of regular
+expression patterns, called "tag patterns".  Tag patterns are
+used to match sequences of tags.  Examples of tag patterns are::
+
+     r'(<DT>|<JJ>|<NN>)+'
+     r'<NN>+'
+     r'<NN.*>'
+
+The differences between regular expression patterns and tag
+patterns are:
+
+    - In tag patterns, ``'<'`` and ``'>'`` act as parentheses; so
+      ``'<NN>+'`` matches one or more repetitions of ``'<NN>'``, not
+      ``'<NN'`` followed by one or more repetitions of ``'>'``.
+    - Whitespace in tag patterns is ignored.  So
+      ``'<DT> | <NN>'`` is equivalent to ``'<DT>|<NN>'``
+    - In tag patterns, ``'.'`` is equivalent to ``'[^{}<>]'``; so
+      ``'<NN.*>'`` matches any single tag starting with ``'NN'``.
+
+The function ``tag_pattern2re_pattern`` can be used to transform
+a tag pattern to an equivalent regular expression pattern.
+
+Efficiency
+----------
+
+Preliminary tests indicate that ``RegexpChunkParser`` can chunk at a
+rate of about 300 tokens/second, with a moderately complex rule set.
+
+There may be problems if ``RegexpChunkParser`` is used with more than
+5,000 tokens at a time.  In particular, evaluation of some regular
+expressions may cause the Python regular expression engine to
+exceed its maximum recursion depth.  We have attempted to minimize
+these problems, but it is impossible to avoid them completely.  We
+therefore recommend that you apply the chunk parser to a single
+sentence at a time.
+
+Emacs Tip
+---------
+
+If you evaluate the following elisp expression in emacs, it will
+colorize a ``ChunkString`` when you use an interactive python shell
+with emacs or xemacs ("C-c !")::
+
+    (let ()
+      (defconst comint-mode-font-lock-keywords
+        '(("<[^>]+>" 0 'font-lock-reference-face)
+          ("[{}]" 0 'font-lock-function-name-face)))
+      (add-hook 'comint-mode-hook (lambda () (turn-on-font-lock))))
+
+You can evaluate this code by copying it to a temporary buffer,
+placing the cursor after the last close parenthesis, and typing
+"``C-x C-e``".  You should evaluate it before running the interactive
+session.  The change will last until you close emacs.
+
+Unresolved Issues
+-----------------
+
+If we use the ``re`` module for regular expressions, Python's
+regular expression engine generates "maximum recursion depth
+exceeded" errors when processing very large texts, even for
+regular expressions that should not require any recursion.  We
+therefore use the ``pre`` module instead.  But note that ``pre``
+does not include Unicode support, so this module will not work
+with unicode strings.  Note also that ``pre`` regular expressions
+are not quite as advanced as ``re`` ones (e.g., no leftward
+zero-length assertions).
+
+:type CHUNK_TAG_PATTERN: regexp
+:var CHUNK_TAG_PATTERN: A regular expression to test whether a tag
+     pattern is valid.
+"""
+
+from nltk.chunk.api import ChunkParserI
+from nltk.chunk.regexp import RegexpChunkParser, RegexpParser
+from nltk.chunk.util import (
+    ChunkScore,
+    accuracy,
+    conllstr2tree,
+    conlltags2tree,
+    ieerstr2tree,
+    tagstr2tree,
+    tree2conllstr,
+    tree2conlltags,
+)
+from nltk.data import load
+
+# Standard treebank POS tagger
+_BINARY_NE_CHUNKER = "chunkers/maxent_ne_chunker/english_ace_binary.pickle"
+_MULTICLASS_NE_CHUNKER = "chunkers/maxent_ne_chunker/english_ace_multiclass.pickle"
+
+
+def ne_chunk(tagged_tokens, binary=False):
+    """
+    Use NLTK's currently recommended named entity chunker to
+    chunk the given list of tagged tokens.
+    """
+    if binary:
+        chunker_pickle = _BINARY_NE_CHUNKER
+    else:
+        chunker_pickle = _MULTICLASS_NE_CHUNKER
+    chunker = load(chunker_pickle)
+    return chunker.parse(tagged_tokens)
+
+
+def ne_chunk_sents(tagged_sentences, binary=False):
+    """
+    Use NLTK's currently recommended named entity chunker to chunk the
+    given list of tagged sentences, each consisting of a list of tagged tokens.
+    """
+    if binary:
+        chunker_pickle = _BINARY_NE_CHUNKER
+    else:
+        chunker_pickle = _MULTICLASS_NE_CHUNKER
+    chunker = load(chunker_pickle)
+    return chunker.parse_sents(tagged_sentences)

llmeval-env/lib/python3.10/site-packages/nltk/chunk/api.py

@@ -0,0 +1,56 @@
+# Natural Language Toolkit: Chunk parsing API
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]> (minor additions)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+##//////////////////////////////////////////////////////
+##  Chunk Parser Interface
+##//////////////////////////////////////////////////////
+
+from nltk.chunk.util import ChunkScore
+from nltk.internals import deprecated
+from nltk.parse import ParserI
+
+
+class ChunkParserI(ParserI):
+    """
+    A processing interface for identifying non-overlapping groups in
+    unrestricted text.  Typically, chunk parsers are used to find base
+    syntactic constituents, such as base noun phrases.  Unlike
+    ``ParserI``, ``ChunkParserI`` guarantees that the ``parse()`` method
+    will always generate a parse.
+    """
+
+    def parse(self, tokens):
+        """
+        Return the best chunk structure for the given tokens
+        and return a tree.
+
+        :param tokens: The list of (word, tag) tokens to be chunked.
+        :type tokens: list(tuple)
+        :rtype: Tree
+        """
+        raise NotImplementedError()
+
+    @deprecated("Use accuracy(gold) instead.")
+    def evaluate(self, gold):
+        return self.accuracy(gold)
+
+    def accuracy(self, gold):
+        """
+        Score the accuracy of the chunker against the gold standard.
+        Remove the chunking the gold standard text, rechunk it using
+        the chunker, and return a ``ChunkScore`` object
+        reflecting the performance of this chunk parser.
+
+        :type gold: list(Tree)
+        :param gold: The list of chunked sentences to score the chunker on.
+        :rtype: ChunkScore
+        """
+        chunkscore = ChunkScore()
+        for correct in gold:
+            chunkscore.score(correct, self.parse(correct.leaves()))
+        return chunkscore

llmeval-env/lib/python3.10/site-packages/nltk/chunk/named_entity.py

@@ -0,0 +1,352 @@
+# Natural Language Toolkit: Chunk parsing API
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Named entity chunker
+"""
+
+import os
+import pickle
+import re
+from xml.etree import ElementTree as ET
+
+from nltk.tag import ClassifierBasedTagger, pos_tag
+
+try:
+    from nltk.classify import MaxentClassifier
+except ImportError:
+    pass
+
+from nltk.chunk.api import ChunkParserI
+from nltk.chunk.util import ChunkScore
+from nltk.data import find
+from nltk.tokenize import word_tokenize
+from nltk.tree import Tree
+
+
+class NEChunkParserTagger(ClassifierBasedTagger):
+    """
+    The IOB tagger used by the chunk parser.
+    """
+
+    def __init__(self, train):
+        ClassifierBasedTagger.__init__(
+            self, train=train, classifier_builder=self._classifier_builder
+        )
+
+    def _classifier_builder(self, train):
+        return MaxentClassifier.train(
+            train, algorithm="megam", gaussian_prior_sigma=1, trace=2
+        )
+
+    def _english_wordlist(self):
+        try:
+            wl = self._en_wordlist
+        except AttributeError:
+            from nltk.corpus import words
+
+            self._en_wordlist = set(words.words("en-basic"))
+            wl = self._en_wordlist
+        return wl
+
+    def _feature_detector(self, tokens, index, history):
+        word = tokens[index][0]
+        pos = simplify_pos(tokens[index][1])
+        if index == 0:
+            prevword = prevprevword = None
+            prevpos = prevprevpos = None
+            prevshape = prevtag = prevprevtag = None
+        elif index == 1:
+            prevword = tokens[index - 1][0].lower()
+            prevprevword = None
+            prevpos = simplify_pos(tokens[index - 1][1])
+            prevprevpos = None
+            prevtag = history[index - 1][0]
+            prevshape = prevprevtag = None
+        else:
+            prevword = tokens[index - 1][0].lower()
+            prevprevword = tokens[index - 2][0].lower()
+            prevpos = simplify_pos(tokens[index - 1][1])
+            prevprevpos = simplify_pos(tokens[index - 2][1])
+            prevtag = history[index - 1]
+            prevprevtag = history[index - 2]
+            prevshape = shape(prevword)
+        if index == len(tokens) - 1:
+            nextword = nextnextword = None
+            nextpos = nextnextpos = None
+        elif index == len(tokens) - 2:
+            nextword = tokens[index + 1][0].lower()
+            nextpos = tokens[index + 1][1].lower()
+            nextnextword = None
+            nextnextpos = None
+        else:
+            nextword = tokens[index + 1][0].lower()
+            nextpos = tokens[index + 1][1].lower()
+            nextnextword = tokens[index + 2][0].lower()
+            nextnextpos = tokens[index + 2][1].lower()
+
+        # 89.6
+        features = {
+            "bias": True,
+            "shape": shape(word),
+            "wordlen": len(word),
+            "prefix3": word[:3].lower(),
+            "suffix3": word[-3:].lower(),
+            "pos": pos,
+            "word": word,
+            "en-wordlist": (word in self._english_wordlist()),
+            "prevtag": prevtag,
+            "prevpos": prevpos,
+            "nextpos": nextpos,
+            "prevword": prevword,
+            "nextword": nextword,
+            "word+nextpos": f"{word.lower()}+{nextpos}",
+            "pos+prevtag": f"{pos}+{prevtag}",
+            "shape+prevtag": f"{prevshape}+{prevtag}",
+        }
+
+        return features
+
+
+class NEChunkParser(ChunkParserI):
+    """
+    Expected input: list of pos-tagged words
+    """
+
+    def __init__(self, train):
+        self._train(train)
+
+    def parse(self, tokens):
+        """
+        Each token should be a pos-tagged word
+        """
+        tagged = self._tagger.tag(tokens)
+        tree = self._tagged_to_parse(tagged)
+        return tree
+
+    def _train(self, corpus):
+        # Convert to tagged sequence
+        corpus = [self._parse_to_tagged(s) for s in corpus]
+
+        self._tagger = NEChunkParserTagger(train=corpus)
+
+    def _tagged_to_parse(self, tagged_tokens):
+        """
+        Convert a list of tagged tokens to a chunk-parse tree.
+        """
+        sent = Tree("S", [])
+
+        for (tok, tag) in tagged_tokens:
+            if tag == "O":
+                sent.append(tok)
+            elif tag.startswith("B-"):
+                sent.append(Tree(tag[2:], [tok]))
+            elif tag.startswith("I-"):
+                if sent and isinstance(sent[-1], Tree) and sent[-1].label() == tag[2:]:
+                    sent[-1].append(tok)
+                else:
+                    sent.append(Tree(tag[2:], [tok]))
+        return sent
+
+    @staticmethod
+    def _parse_to_tagged(sent):
+        """
+        Convert a chunk-parse tree to a list of tagged tokens.
+        """
+        toks = []
+        for child in sent:
+            if isinstance(child, Tree):
+                if len(child) == 0:
+                    print("Warning -- empty chunk in sentence")
+                    continue
+                toks.append((child[0], f"B-{child.label()}"))
+                for tok in child[1:]:
+                    toks.append((tok, f"I-{child.label()}"))
+            else:
+                toks.append((child, "O"))
+        return toks
+
+
+def shape(word):
+    if re.match(r"[0-9]+(\.[0-9]*)?|[0-9]*\.[0-9]+$", word, re.UNICODE):
+        return "number"
+    elif re.match(r"\W+$", word, re.UNICODE):
+        return "punct"
+    elif re.match(r"\w+$", word, re.UNICODE):
+        if word.istitle():
+            return "upcase"
+        elif word.islower():
+            return "downcase"
+        else:
+            return "mixedcase"
+    else:
+        return "other"
+
+
+def simplify_pos(s):
+    if s.startswith("V"):
+        return "V"
+    else:
+        return s.split("-")[0]
+
+
+def postag_tree(tree):
+    # Part-of-speech tagging.
+    words = tree.leaves()
+    tag_iter = (pos for (word, pos) in pos_tag(words))
+    newtree = Tree("S", [])
+    for child in tree:
+        if isinstance(child, Tree):
+            newtree.append(Tree(child.label(), []))
+            for subchild in child:
+                newtree[-1].append((subchild, next(tag_iter)))
+        else:
+            newtree.append((child, next(tag_iter)))
+    return newtree
+
+
+def load_ace_data(roots, fmt="binary", skip_bnews=True):
+    for root in roots:
+        for root, dirs, files in os.walk(root):
+            if root.endswith("bnews") and skip_bnews:
+                continue
+            for f in files:
+                if f.endswith(".sgm"):
+                    yield from load_ace_file(os.path.join(root, f), fmt)
+
+
+def load_ace_file(textfile, fmt):
+    print(f"  - {os.path.split(textfile)[1]}")
+    annfile = textfile + ".tmx.rdc.xml"
+
+    # Read the xml file, and get a list of entities
+    entities = []
+    with open(annfile) as infile:
+        xml = ET.parse(infile).getroot()
+    for entity in xml.findall("document/entity"):
+        typ = entity.find("entity_type").text
+        for mention in entity.findall("entity_mention"):
+            if mention.get("TYPE") != "NAME":
+                continue  # only NEs
+            s = int(mention.find("head/charseq/start").text)
+            e = int(mention.find("head/charseq/end").text) + 1
+            entities.append((s, e, typ))
+
+    # Read the text file, and mark the entities.
+    with open(textfile) as infile:
+        text = infile.read()
+
+    # Strip XML tags, since they don't count towards the indices
+    text = re.sub("<(?!/?TEXT)[^>]+>", "", text)
+
+    # Blank out anything before/after <TEXT>
+    def subfunc(m):
+        return " " * (m.end() - m.start() - 6)
+
+    text = re.sub(r"[\s\S]*<TEXT>", subfunc, text)
+    text = re.sub(r"</TEXT>[\s\S]*", "", text)
+
+    # Simplify quotes
+    text = re.sub("``", ' "', text)
+    text = re.sub("''", '" ', text)
+
+    entity_types = {typ for (s, e, typ) in entities}
+
+    # Binary distinction (NE or not NE)
+    if fmt == "binary":
+        i = 0
+        toks = Tree("S", [])
+        for (s, e, typ) in sorted(entities):
+            if s < i:
+                s = i  # Overlapping!  Deal with this better?
+            if e <= s:
+                continue
+            toks.extend(word_tokenize(text[i:s]))
+            toks.append(Tree("NE", text[s:e].split()))
+            i = e
+        toks.extend(word_tokenize(text[i:]))
+        yield toks
+
+    # Multiclass distinction (NE type)
+    elif fmt == "multiclass":
+        i = 0
+        toks = Tree("S", [])
+        for (s, e, typ) in sorted(entities):
+            if s < i:
+                s = i  # Overlapping!  Deal with this better?
+            if e <= s:
+                continue
+            toks.extend(word_tokenize(text[i:s]))
+            toks.append(Tree(typ, text[s:e].split()))
+            i = e
+        toks.extend(word_tokenize(text[i:]))
+        yield toks
+
+    else:
+        raise ValueError("bad fmt value")
+
+
+# This probably belongs in a more general-purpose location (as does
+# the parse_to_tagged function).
+def cmp_chunks(correct, guessed):
+    correct = NEChunkParser._parse_to_tagged(correct)
+    guessed = NEChunkParser._parse_to_tagged(guessed)
+    ellipsis = False
+    for (w, ct), (w, gt) in zip(correct, guessed):
+        if ct == gt == "O":
+            if not ellipsis:
+                print(f"  {ct:15} {gt:15} {w}")
+                print("  {:15} {:15} {2}".format("...", "...", "..."))
+                ellipsis = True
+        else:
+            ellipsis = False
+            print(f"  {ct:15} {gt:15} {w}")
+
+
+def build_model(fmt="binary"):
+    print("Loading training data...")
+    train_paths = [
+        find("corpora/ace_data/ace.dev"),
+        find("corpora/ace_data/ace.heldout"),
+        find("corpora/ace_data/bbn.dev"),
+        find("corpora/ace_data/muc.dev"),
+    ]
+    train_trees = load_ace_data(train_paths, fmt)
+    train_data = [postag_tree(t) for t in train_trees]
+    print("Training...")
+    cp = NEChunkParser(train_data)
+    del train_data
+
+    print("Loading eval data...")
+    eval_paths = [find("corpora/ace_data/ace.eval")]
+    eval_trees = load_ace_data(eval_paths, fmt)
+    eval_data = [postag_tree(t) for t in eval_trees]
+
+    print("Evaluating...")
+    chunkscore = ChunkScore()
+    for i, correct in enumerate(eval_data):
+        guess = cp.parse(correct.leaves())
+        chunkscore.score(correct, guess)
+        if i < 3:
+            cmp_chunks(correct, guess)
+    print(chunkscore)
+
+    outfilename = f"/tmp/ne_chunker_{fmt}.pickle"
+    print(f"Saving chunker to {outfilename}...")
+
+    with open(outfilename, "wb") as outfile:
+        pickle.dump(cp, outfile, -1)
+
+    return cp
+
+
+if __name__ == "__main__":
+    # Make sure that the pickled object has the right class name:
+    from nltk.chunk.named_entity import build_model
+
+    build_model("binary")
+    build_model("multiclass")

llmeval-env/lib/python3.10/site-packages/nltk/chunk/regexp.py

@@ -0,0 +1,1475 @@
+# Natural Language Toolkit: Regular Expression Chunkers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]> (minor additions)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import re
+
+import regex
+
+from nltk.chunk.api import ChunkParserI
+from nltk.tree import Tree
+
+# //////////////////////////////////////////////////////
+# ChunkString
+# //////////////////////////////////////////////////////
+
+
+class ChunkString:
+    """
+    A string-based encoding of a particular chunking of a text.
+    Internally, the ``ChunkString`` class uses a single string to
+    encode the chunking of the input text.  This string contains a
+    sequence of angle-bracket delimited tags, with chunking indicated
+    by braces.  An example of this encoding is::
+
+        {<DT><JJ><NN>}<VBN><IN>{<DT><NN>}<.>{<DT><NN>}<VBD><.>
+
+    ``ChunkString`` are created from tagged texts (i.e., lists of
+    ``tokens`` whose type is ``TaggedType``).  Initially, nothing is
+    chunked.
+
+    The chunking of a ``ChunkString`` can be modified with the ``xform()``
+    method, which uses a regular expression to transform the string
+    representation.  These transformations should only add and remove
+    braces; they should *not* modify the sequence of angle-bracket
+    delimited tags.
+
+    :type _str: str
+    :ivar _str: The internal string representation of the text's
+        encoding.  This string representation contains a sequence of
+        angle-bracket delimited tags, with chunking indicated by
+        braces.  An example of this encoding is::
+
+            {<DT><JJ><NN>}<VBN><IN>{<DT><NN>}<.>{<DT><NN>}<VBD><.>
+
+    :type _pieces: list(tagged tokens and chunks)
+    :ivar _pieces: The tagged tokens and chunks encoded by this ``ChunkString``.
+    :ivar _debug: The debug level.  See the constructor docs.
+
+    :cvar IN_CHUNK_PATTERN: A zero-width regexp pattern string that
+        will only match positions that are in chunks.
+    :cvar IN_STRIP_PATTERN: A zero-width regexp pattern string that
+        will only match positions that are in strips.
+    """
+
+    CHUNK_TAG_CHAR = r"[^\{\}<>]"
+    CHUNK_TAG = r"(<%s+?>)" % CHUNK_TAG_CHAR
+
+    IN_CHUNK_PATTERN = r"(?=[^\{]*\})"
+    IN_STRIP_PATTERN = r"(?=[^\}]*(\{|$))"
+
+    # These are used by _verify
+    _CHUNK = r"(\{%s+?\})+?" % CHUNK_TAG
+    _STRIP = r"(%s+?)+?" % CHUNK_TAG
+    _VALID = re.compile(r"^(\{?%s\}?)*?$" % CHUNK_TAG)
+    _BRACKETS = re.compile(r"[^\{\}]+")
+    _BALANCED_BRACKETS = re.compile(r"(\{\})*$")
+
+    def __init__(self, chunk_struct, debug_level=1):
+        """
+        Construct a new ``ChunkString`` that encodes the chunking of
+        the text ``tagged_tokens``.
+
+        :type chunk_struct: Tree
+        :param chunk_struct: The chunk structure to be further chunked.
+        :type debug_level: int
+        :param debug_level: The level of debugging which should be
+            applied to transformations on the ``ChunkString``.  The
+            valid levels are:
+
+                - 0: no checks
+                - 1: full check on to_chunkstruct
+                - 2: full check on to_chunkstruct and cursory check after
+                  each transformation.
+                - 3: full check on to_chunkstruct and full check after
+                  each transformation.
+
+            We recommend you use at least level 1.  You should
+            probably use level 3 if you use any non-standard
+            subclasses of ``RegexpChunkRule``.
+        """
+        self._root_label = chunk_struct.label()
+        self._pieces = chunk_struct[:]
+        tags = [self._tag(tok) for tok in self._pieces]
+        self._str = "<" + "><".join(tags) + ">"
+        self._debug = debug_level
+
+    def _tag(self, tok):
+        if isinstance(tok, tuple):
+            return tok[1]
+        elif isinstance(tok, Tree):
+            return tok.label()
+        else:
+            raise ValueError("chunk structures must contain tagged " "tokens or trees")
+
+    def _verify(self, s, verify_tags):
+        """
+        Check to make sure that ``s`` still corresponds to some chunked
+        version of ``_pieces``.
+
+        :type verify_tags: bool
+        :param verify_tags: Whether the individual tags should be
+            checked.  If this is false, ``_verify`` will check to make
+            sure that ``_str`` encodes a chunked version of *some*
+            list of tokens.  If this is true, then ``_verify`` will
+            check to make sure that the tags in ``_str`` match those in
+            ``_pieces``.
+
+        :raise ValueError: if the internal string representation of
+            this ``ChunkString`` is invalid or not consistent with _pieces.
+        """
+        # Check overall form
+        if not ChunkString._VALID.match(s):
+            raise ValueError(
+                "Transformation generated invalid " "chunkstring:\n  %s" % s
+            )
+
+        # Check that parens are balanced.  If the string is long, we
+        # have to do this in pieces, to avoid a maximum recursion
+        # depth limit for regular expressions.
+        brackets = ChunkString._BRACKETS.sub("", s)
+        for i in range(1 + len(brackets) // 5000):
+            substr = brackets[i * 5000 : i * 5000 + 5000]
+            if not ChunkString._BALANCED_BRACKETS.match(substr):
+                raise ValueError(
+                    "Transformation generated invalid " "chunkstring:\n  %s" % s
+                )
+
+        if verify_tags <= 0:
+            return
+
+        tags1 = (re.split(r"[\{\}<>]+", s))[1:-1]
+        tags2 = [self._tag(piece) for piece in self._pieces]
+        if tags1 != tags2:
+            raise ValueError(
+                "Transformation generated invalid " "chunkstring: tag changed"
+            )
+
+    def to_chunkstruct(self, chunk_label="CHUNK"):
+        """
+        Return the chunk structure encoded by this ``ChunkString``.
+
+        :rtype: Tree
+        :raise ValueError: If a transformation has generated an
+            invalid chunkstring.
+        """
+        if self._debug > 0:
+            self._verify(self._str, 1)
+
+        # Use this alternating list to create the chunkstruct.
+        pieces = []
+        index = 0
+        piece_in_chunk = 0
+        for piece in re.split("[{}]", self._str):
+
+            # Find the list of tokens contained in this piece.
+            length = piece.count("<")
+            subsequence = self._pieces[index : index + length]
+
+            # Add this list of tokens to our pieces.
+            if piece_in_chunk:
+                pieces.append(Tree(chunk_label, subsequence))
+            else:
+                pieces += subsequence
+
+            # Update index, piece_in_chunk
+            index += length
+            piece_in_chunk = not piece_in_chunk
+
+        return Tree(self._root_label, pieces)
+
+    def xform(self, regexp, repl):
+        """
+        Apply the given transformation to the string encoding of this
+        ``ChunkString``.  In particular, find all occurrences that match
+        ``regexp``, and replace them using ``repl`` (as done by
+        ``re.sub``).
+
+        This transformation should only add and remove braces; it
+        should *not* modify the sequence of angle-bracket delimited
+        tags.  Furthermore, this transformation may not result in
+        improper bracketing.  Note, in particular, that bracketing may
+        not be nested.
+
+        :type regexp: str or regexp
+        :param regexp: A regular expression matching the substring
+            that should be replaced.  This will typically include a
+            named group, which can be used by ``repl``.
+        :type repl: str
+        :param repl: An expression specifying what should replace the
+            matched substring.  Typically, this will include a named
+            replacement group, specified by ``regexp``.
+        :rtype: None
+        :raise ValueError: If this transformation generated an
+            invalid chunkstring.
+        """
+        # Do the actual substitution
+        s = re.sub(regexp, repl, self._str)
+
+        # The substitution might have generated "empty chunks"
+        # (substrings of the form "{}").  Remove them, so they don't
+        # interfere with other transformations.
+        s = re.sub(r"\{\}", "", s)
+
+        # Make sure that the transformation was legal.
+        if self._debug > 1:
+            self._verify(s, self._debug - 2)
+
+        # Commit the transformation.
+        self._str = s
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ChunkString``.
+        It has the form::
+
+            <ChunkString: '{<DT><JJ><NN>}<VBN><IN>{<DT><NN>}'>
+
+        :rtype: str
+        """
+        return "<ChunkString: %s>" % repr(self._str)
+
+    def __str__(self):
+        """
+        Return a formatted representation of this ``ChunkString``.
+        This representation will include extra spaces to ensure that
+        tags will line up with the representation of other
+        ``ChunkStrings`` for the same text, regardless of the chunking.
+
+        :rtype: str
+        """
+        # Add spaces to make everything line up.
+        str = re.sub(r">(?!\})", r"> ", self._str)
+        str = re.sub(r"([^\{])<", r"\1 <", str)
+        if str[0] == "<":
+            str = " " + str
+        return str
+
+
+# //////////////////////////////////////////////////////
+# Chunking Rules
+# //////////////////////////////////////////////////////
+
+
+class RegexpChunkRule:
+    """
+    A rule specifying how to modify the chunking in a ``ChunkString``,
+    using a transformational regular expression.  The
+    ``RegexpChunkRule`` class itself can be used to implement any
+    transformational rule based on regular expressions.  There are
+    also a number of subclasses, which can be used to implement
+    simpler types of rules, based on matching regular expressions.
+
+    Each ``RegexpChunkRule`` has a regular expression and a
+    replacement expression.  When a ``RegexpChunkRule`` is "applied"
+    to a ``ChunkString``, it searches the ``ChunkString`` for any
+    substring that matches the regular expression, and replaces it
+    using the replacement expression.  This search/replace operation
+    has the same semantics as ``re.sub``.
+
+    Each ``RegexpChunkRule`` also has a description string, which
+    gives a short (typically less than 75 characters) description of
+    the purpose of the rule.
+
+    This transformation defined by this ``RegexpChunkRule`` should
+    only add and remove braces; it should *not* modify the sequence
+    of angle-bracket delimited tags.  Furthermore, this transformation
+    may not result in nested or mismatched bracketing.
+    """
+
+    def __init__(self, regexp, repl, descr):
+        """
+        Construct a new RegexpChunkRule.
+
+        :type regexp: regexp or str
+        :param regexp: The regular expression for this ``RegexpChunkRule``.
+            When this rule is applied to a ``ChunkString``, any
+            substring that matches ``regexp`` will be replaced using
+            the replacement string ``repl``.  Note that this must be a
+            normal regular expression, not a tag pattern.
+        :type repl: str
+        :param repl: The replacement expression for this ``RegexpChunkRule``.
+            When this rule is applied to a ``ChunkString``, any substring
+            that matches ``regexp`` will be replaced using ``repl``.
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        if isinstance(regexp, str):
+            regexp = re.compile(regexp)
+        self._repl = repl
+        self._descr = descr
+        self._regexp = regexp
+
+    def apply(self, chunkstr):
+        # Keep docstring generic so we can inherit it.
+        """
+        Apply this rule to the given ``ChunkString``.  See the
+        class reference documentation for a description of what it
+        means to apply a rule.
+
+        :type chunkstr: ChunkString
+        :param chunkstr: The chunkstring to which this rule is applied.
+        :rtype: None
+        :raise ValueError: If this transformation generated an
+            invalid chunkstring.
+        """
+        chunkstr.xform(self._regexp, self._repl)
+
+    def descr(self):
+        """
+        Return a short description of the purpose and/or effect of
+        this rule.
+
+        :rtype: str
+        """
+        return self._descr
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <RegexpChunkRule: '{<IN|VB.*>}'->'<IN>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return (
+            "<RegexpChunkRule: "
+            + repr(self._regexp.pattern)
+            + "->"
+            + repr(self._repl)
+            + ">"
+        )
+
+    @staticmethod
+    def fromstring(s):
+        """
+        Create a RegexpChunkRule from a string description.
+        Currently, the following formats are supported::
+
+          {regexp}         # chunk rule
+          }regexp{         # strip rule
+          regexp}{regexp   # split rule
+          regexp{}regexp   # merge rule
+
+        Where ``regexp`` is a regular expression for the rule.  Any
+        text following the comment marker (``#``) will be used as
+        the rule's description:
+
+        >>> from nltk.chunk.regexp import RegexpChunkRule
+        >>> RegexpChunkRule.fromstring('{<DT>?<NN.*>+}')
+        <ChunkRule: '<DT>?<NN.*>+'>
+        """
+        # Split off the comment (but don't split on '\#')
+        m = re.match(r"(?P<rule>(\\.|[^#])*)(?P<comment>#.*)?", s)
+        rule = m.group("rule").strip()
+        comment = (m.group("comment") or "")[1:].strip()
+
+        # Pattern bodies: chunk, strip, split, merge
+        try:
+            if not rule:
+                raise ValueError("Empty chunk pattern")
+            if rule[0] == "{" and rule[-1] == "}":
+                return ChunkRule(rule[1:-1], comment)
+            elif rule[0] == "}" and rule[-1] == "{":
+                return StripRule(rule[1:-1], comment)
+            elif "}{" in rule:
+                left, right = rule.split("}{")
+                return SplitRule(left, right, comment)
+            elif "{}" in rule:
+                left, right = rule.split("{}")
+                return MergeRule(left, right, comment)
+            elif re.match("[^{}]*{[^{}]*}[^{}]*", rule):
+                left, chunk, right = re.split("[{}]", rule)
+                return ChunkRuleWithContext(left, chunk, right, comment)
+            else:
+                raise ValueError("Illegal chunk pattern: %s" % rule)
+        except (ValueError, re.error) as e:
+            raise ValueError("Illegal chunk pattern: %s" % rule) from e
+
+
+class ChunkRule(RegexpChunkRule):
+    """
+    A rule specifying how to add chunks to a ``ChunkString``, using a
+    matching tag pattern.  When applied to a ``ChunkString``, it will
+    find any substring that matches this tag pattern and that is not
+    already part of a chunk, and create a new chunk containing that
+    substring.
+    """
+
+    def __init__(self, tag_pattern, descr):
+        """
+        Construct a new ``ChunkRule``.
+
+        :type tag_pattern: str
+        :param tag_pattern: This rule's tag pattern.  When
+            applied to a ``ChunkString``, this rule will
+            chunk any substring that matches this tag pattern and that
+            is not already part of a chunk.
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        self._pattern = tag_pattern
+        regexp = re.compile(
+            "(?P<chunk>%s)%s"
+            % (tag_pattern2re_pattern(tag_pattern), ChunkString.IN_STRIP_PATTERN)
+        )
+        RegexpChunkRule.__init__(self, regexp, r"{\g<chunk>}", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <ChunkRule: '<IN|VB.*>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return "<ChunkRule: " + repr(self._pattern) + ">"
+
+
+class StripRule(RegexpChunkRule):
+    """
+    A rule specifying how to remove strips to a ``ChunkString``,
+    using a matching tag pattern.  When applied to a
+    ``ChunkString``, it will find any substring that matches this
+    tag pattern and that is contained in a chunk, and remove it
+    from that chunk, thus creating two new chunks.
+    """
+
+    def __init__(self, tag_pattern, descr):
+        """
+        Construct a new ``StripRule``.
+
+        :type tag_pattern: str
+        :param tag_pattern: This rule's tag pattern.  When
+            applied to a ``ChunkString``, this rule will
+            find any substring that matches this tag pattern and that
+            is contained in a chunk, and remove it from that chunk,
+            thus creating two new chunks.
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        self._pattern = tag_pattern
+        regexp = re.compile(
+            "(?P<strip>%s)%s"
+            % (tag_pattern2re_pattern(tag_pattern), ChunkString.IN_CHUNK_PATTERN)
+        )
+        RegexpChunkRule.__init__(self, regexp, r"}\g<strip>{", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <StripRule: '<IN|VB.*>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return "<StripRule: " + repr(self._pattern) + ">"
+
+
+class UnChunkRule(RegexpChunkRule):
+    """
+    A rule specifying how to remove chunks to a ``ChunkString``,
+    using a matching tag pattern.  When applied to a
+    ``ChunkString``, it will find any complete chunk that matches this
+    tag pattern, and un-chunk it.
+    """
+
+    def __init__(self, tag_pattern, descr):
+        """
+        Construct a new ``UnChunkRule``.
+
+        :type tag_pattern: str
+        :param tag_pattern: This rule's tag pattern.  When
+            applied to a ``ChunkString``, this rule will
+            find any complete chunk that matches this tag pattern,
+            and un-chunk it.
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        self._pattern = tag_pattern
+        regexp = re.compile(r"\{(?P<chunk>%s)\}" % tag_pattern2re_pattern(tag_pattern))
+        RegexpChunkRule.__init__(self, regexp, r"\g<chunk>", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <UnChunkRule: '<IN|VB.*>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return "<UnChunkRule: " + repr(self._pattern) + ">"
+
+
+class MergeRule(RegexpChunkRule):
+    """
+    A rule specifying how to merge chunks in a ``ChunkString``, using
+    two matching tag patterns: a left pattern, and a right pattern.
+    When applied to a ``ChunkString``, it will find any chunk whose end
+    matches left pattern, and immediately followed by a chunk whose
+    beginning matches right pattern.  It will then merge those two
+    chunks into a single chunk.
+    """
+
+    def __init__(self, left_tag_pattern, right_tag_pattern, descr):
+        """
+        Construct a new ``MergeRule``.
+
+        :type right_tag_pattern: str
+        :param right_tag_pattern: This rule's right tag
+            pattern.  When applied to a ``ChunkString``, this
+            rule will find any chunk whose end matches
+            ``left_tag_pattern``, and immediately followed by a chunk
+            whose beginning matches this pattern.  It will
+            then merge those two chunks into a single chunk.
+        :type left_tag_pattern: str
+        :param left_tag_pattern: This rule's left tag
+            pattern.  When applied to a ``ChunkString``, this
+            rule will find any chunk whose end matches
+            this pattern, and immediately followed by a chunk
+            whose beginning matches ``right_tag_pattern``.  It will
+            then merge those two chunks into a single chunk.
+
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        # Ensure that the individual patterns are coherent.  E.g., if
+        # left='(' and right=')', then this will raise an exception:
+        re.compile(tag_pattern2re_pattern(left_tag_pattern))
+        re.compile(tag_pattern2re_pattern(right_tag_pattern))
+
+        self._left_tag_pattern = left_tag_pattern
+        self._right_tag_pattern = right_tag_pattern
+        regexp = re.compile(
+            "(?P<left>%s)}{(?=%s)"
+            % (
+                tag_pattern2re_pattern(left_tag_pattern),
+                tag_pattern2re_pattern(right_tag_pattern),
+            )
+        )
+        RegexpChunkRule.__init__(self, regexp, r"\g<left>", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <MergeRule: '<NN|DT|JJ>', '<NN|JJ>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return (
+            "<MergeRule: "
+            + repr(self._left_tag_pattern)
+            + ", "
+            + repr(self._right_tag_pattern)
+            + ">"
+        )
+
+
+class SplitRule(RegexpChunkRule):
+    """
+    A rule specifying how to split chunks in a ``ChunkString``, using
+    two matching tag patterns: a left pattern, and a right pattern.
+    When applied to a ``ChunkString``, it will find any chunk that
+    matches the left pattern followed by the right pattern.  It will
+    then split the chunk into two new chunks, at the point between the
+    two pattern matches.
+    """
+
+    def __init__(self, left_tag_pattern, right_tag_pattern, descr):
+        """
+        Construct a new ``SplitRule``.
+
+        :type right_tag_pattern: str
+        :param right_tag_pattern: This rule's right tag
+            pattern.  When applied to a ``ChunkString``, this rule will
+            find any chunk containing a substring that matches
+            ``left_tag_pattern`` followed by this pattern.  It will
+            then split the chunk into two new chunks at the point
+            between these two matching patterns.
+        :type left_tag_pattern: str
+        :param left_tag_pattern: This rule's left tag
+            pattern.  When applied to a ``ChunkString``, this rule will
+            find any chunk containing a substring that matches this
+            pattern followed by ``right_tag_pattern``.  It will then
+            split the chunk into two new chunks at the point between
+            these two matching patterns.
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        # Ensure that the individual patterns are coherent.  E.g., if
+        # left='(' and right=')', then this will raise an exception:
+        re.compile(tag_pattern2re_pattern(left_tag_pattern))
+        re.compile(tag_pattern2re_pattern(right_tag_pattern))
+
+        self._left_tag_pattern = left_tag_pattern
+        self._right_tag_pattern = right_tag_pattern
+        regexp = re.compile(
+            "(?P<left>%s)(?=%s)"
+            % (
+                tag_pattern2re_pattern(left_tag_pattern),
+                tag_pattern2re_pattern(right_tag_pattern),
+            )
+        )
+        RegexpChunkRule.__init__(self, regexp, r"\g<left>}{", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <SplitRule: '<NN>', '<DT>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return (
+            "<SplitRule: "
+            + repr(self._left_tag_pattern)
+            + ", "
+            + repr(self._right_tag_pattern)
+            + ">"
+        )
+
+
+class ExpandLeftRule(RegexpChunkRule):
+    """
+    A rule specifying how to expand chunks in a ``ChunkString`` to the left,
+    using two matching tag patterns: a left pattern, and a right pattern.
+    When applied to a ``ChunkString``, it will find any chunk whose beginning
+    matches right pattern, and immediately preceded by a strip whose
+    end matches left pattern.  It will then expand the chunk to incorporate
+    the new material on the left.
+    """
+
+    def __init__(self, left_tag_pattern, right_tag_pattern, descr):
+        """
+        Construct a new ``ExpandRightRule``.
+
+        :type right_tag_pattern: str
+        :param right_tag_pattern: This rule's right tag
+            pattern.  When applied to a ``ChunkString``, this
+            rule will find any chunk whose beginning matches
+            ``right_tag_pattern``, and immediately preceded by a strip
+            whose end matches this pattern.  It will
+            then merge those two chunks into a single chunk.
+        :type left_tag_pattern: str
+        :param left_tag_pattern: This rule's left tag
+            pattern.  When applied to a ``ChunkString``, this
+            rule will find any chunk whose beginning matches
+            this pattern, and immediately preceded by a strip
+            whose end matches ``left_tag_pattern``.  It will
+            then expand the chunk to incorporate the new material on the left.
+
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        # Ensure that the individual patterns are coherent.  E.g., if
+        # left='(' and right=')', then this will raise an exception:
+        re.compile(tag_pattern2re_pattern(left_tag_pattern))
+        re.compile(tag_pattern2re_pattern(right_tag_pattern))
+
+        self._left_tag_pattern = left_tag_pattern
+        self._right_tag_pattern = right_tag_pattern
+        regexp = re.compile(
+            r"(?P<left>%s)\{(?P<right>%s)"
+            % (
+                tag_pattern2re_pattern(left_tag_pattern),
+                tag_pattern2re_pattern(right_tag_pattern),
+            )
+        )
+        RegexpChunkRule.__init__(self, regexp, r"{\g<left>\g<right>", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <ExpandLeftRule: '<NN|DT|JJ>', '<NN|JJ>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return (
+            "<ExpandLeftRule: "
+            + repr(self._left_tag_pattern)
+            + ", "
+            + repr(self._right_tag_pattern)
+            + ">"
+        )
+
+
+class ExpandRightRule(RegexpChunkRule):
+    """
+    A rule specifying how to expand chunks in a ``ChunkString`` to the
+    right, using two matching tag patterns: a left pattern, and a
+    right pattern.  When applied to a ``ChunkString``, it will find any
+    chunk whose end matches left pattern, and immediately followed by
+    a strip whose beginning matches right pattern.  It will then
+    expand the chunk to incorporate the new material on the right.
+    """
+
+    def __init__(self, left_tag_pattern, right_tag_pattern, descr):
+        """
+        Construct a new ``ExpandRightRule``.
+
+        :type right_tag_pattern: str
+        :param right_tag_pattern: This rule's right tag
+            pattern.  When applied to a ``ChunkString``, this
+            rule will find any chunk whose end matches
+            ``left_tag_pattern``, and immediately followed by a strip
+            whose beginning matches this pattern.  It will
+            then merge those two chunks into a single chunk.
+        :type left_tag_pattern: str
+        :param left_tag_pattern: This rule's left tag
+            pattern.  When applied to a ``ChunkString``, this
+            rule will find any chunk whose end matches
+            this pattern, and immediately followed by a strip
+            whose beginning matches ``right_tag_pattern``.  It will
+            then expand the chunk to incorporate the new material on the right.
+
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        # Ensure that the individual patterns are coherent.  E.g., if
+        # left='(' and right=')', then this will raise an exception:
+        re.compile(tag_pattern2re_pattern(left_tag_pattern))
+        re.compile(tag_pattern2re_pattern(right_tag_pattern))
+
+        self._left_tag_pattern = left_tag_pattern
+        self._right_tag_pattern = right_tag_pattern
+        regexp = re.compile(
+            r"(?P<left>%s)\}(?P<right>%s)"
+            % (
+                tag_pattern2re_pattern(left_tag_pattern),
+                tag_pattern2re_pattern(right_tag_pattern),
+            )
+        )
+        RegexpChunkRule.__init__(self, regexp, r"\g<left>\g<right>}", descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <ExpandRightRule: '<NN|DT|JJ>', '<NN|JJ>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return (
+            "<ExpandRightRule: "
+            + repr(self._left_tag_pattern)
+            + ", "
+            + repr(self._right_tag_pattern)
+            + ">"
+        )
+
+
+class ChunkRuleWithContext(RegexpChunkRule):
+    """
+    A rule specifying how to add chunks to a ``ChunkString``, using
+    three matching tag patterns: one for the left context, one for the
+    chunk, and one for the right context.  When applied to a
+    ``ChunkString``, it will find any substring that matches the chunk
+    tag pattern, is surrounded by substrings that match the two
+    context patterns, and is not already part of a chunk; and create a
+    new chunk containing the substring that matched the chunk tag
+    pattern.
+
+    Caveat: Both the left and right context are consumed when this
+    rule matches; therefore, if you need to find overlapping matches,
+    you will need to apply your rule more than once.
+    """
+
+    def __init__(
+        self,
+        left_context_tag_pattern,
+        chunk_tag_pattern,
+        right_context_tag_pattern,
+        descr,
+    ):
+        """
+        Construct a new ``ChunkRuleWithContext``.
+
+        :type left_context_tag_pattern: str
+        :param left_context_tag_pattern: A tag pattern that must match
+            the left context of ``chunk_tag_pattern`` for this rule to
+            apply.
+        :type chunk_tag_pattern: str
+        :param chunk_tag_pattern: A tag pattern that must match for this
+            rule to apply.  If the rule does apply, then this pattern
+            also identifies the substring that will be made into a chunk.
+        :type right_context_tag_pattern: str
+        :param right_context_tag_pattern: A tag pattern that must match
+            the right context of ``chunk_tag_pattern`` for this rule to
+            apply.
+        :type descr: str
+        :param descr: A short description of the purpose and/or effect
+            of this rule.
+        """
+        # Ensure that the individual patterns are coherent.  E.g., if
+        # left='(' and right=')', then this will raise an exception:
+        re.compile(tag_pattern2re_pattern(left_context_tag_pattern))
+        re.compile(tag_pattern2re_pattern(chunk_tag_pattern))
+        re.compile(tag_pattern2re_pattern(right_context_tag_pattern))
+
+        self._left_context_tag_pattern = left_context_tag_pattern
+        self._chunk_tag_pattern = chunk_tag_pattern
+        self._right_context_tag_pattern = right_context_tag_pattern
+        regexp = re.compile(
+            "(?P<left>%s)(?P<chunk>%s)(?P<right>%s)%s"
+            % (
+                tag_pattern2re_pattern(left_context_tag_pattern),
+                tag_pattern2re_pattern(chunk_tag_pattern),
+                tag_pattern2re_pattern(right_context_tag_pattern),
+                ChunkString.IN_STRIP_PATTERN,
+            )
+        )
+        replacement = r"\g<left>{\g<chunk>}\g<right>"
+        RegexpChunkRule.__init__(self, regexp, replacement, descr)
+
+    def __repr__(self):
+        """
+        Return a string representation of this rule.  It has the form::
+
+            <ChunkRuleWithContext: '<IN>', '<NN>', '<DT>'>
+
+        Note that this representation does not include the
+        description string; that string can be accessed
+        separately with the ``descr()`` method.
+
+        :rtype: str
+        """
+        return "<ChunkRuleWithContext:  {!r}, {!r}, {!r}>".format(
+            self._left_context_tag_pattern,
+            self._chunk_tag_pattern,
+            self._right_context_tag_pattern,
+        )
+
+
+# //////////////////////////////////////////////////////
+# Tag Pattern Format Conversion
+# //////////////////////////////////////////////////////
+
+# this should probably be made more strict than it is -- e.g., it
+# currently accepts 'foo'.
+CHUNK_TAG_PATTERN = re.compile(
+    r"^(({}|<{}>)*)$".format(r"([^\{\}<>]|\{\d+,?\}|\{\d*,\d+\})+", r"[^\{\}<>]+")
+)
+
+
+def tag_pattern2re_pattern(tag_pattern):
+    """
+    Convert a tag pattern to a regular expression pattern.  A "tag
+    pattern" is a modified version of a regular expression, designed
+    for matching sequences of tags.  The differences between regular
+    expression patterns and tag patterns are:
+
+        - In tag patterns, ``'<'`` and ``'>'`` act as parentheses; so
+          ``'<NN>+'`` matches one or more repetitions of ``'<NN>'``, not
+          ``'<NN'`` followed by one or more repetitions of ``'>'``.
+        - Whitespace in tag patterns is ignored.  So
+          ``'<DT> | <NN>'`` is equivalent to ``'<DT>|<NN>'``
+        - In tag patterns, ``'.'`` is equivalent to ``'[^{}<>]'``; so
+          ``'<NN.*>'`` matches any single tag starting with ``'NN'``.
+
+    In particular, ``tag_pattern2re_pattern`` performs the following
+    transformations on the given pattern:
+
+        - Replace '.' with '[^<>{}]'
+        - Remove any whitespace
+        - Add extra parens around '<' and '>', to make '<' and '>' act
+          like parentheses.  E.g., so that in '<NN>+', the '+' has scope
+          over the entire '<NN>'; and so that in '<NN|IN>', the '|' has
+          scope over 'NN' and 'IN', but not '<' or '>'.
+        - Check to make sure the resulting pattern is valid.
+
+    :type tag_pattern: str
+    :param tag_pattern: The tag pattern to convert to a regular
+        expression pattern.
+    :raise ValueError: If ``tag_pattern`` is not a valid tag pattern.
+        In particular, ``tag_pattern`` should not include braces; and it
+        should not contain nested or mismatched angle-brackets.
+    :rtype: str
+    :return: A regular expression pattern corresponding to
+        ``tag_pattern``.
+    """
+    # Clean up the regular expression
+    tag_pattern = re.sub(r"\s", "", tag_pattern)
+    tag_pattern = re.sub(r"<", "(<(", tag_pattern)
+    tag_pattern = re.sub(r">", ")>)", tag_pattern)
+
+    # Check the regular expression
+    if not CHUNK_TAG_PATTERN.match(tag_pattern):
+        raise ValueError("Bad tag pattern: %r" % tag_pattern)
+
+    # Replace "." with CHUNK_TAG_CHAR.
+    # We have to do this after, since it adds {}[]<>s, which would
+    # confuse CHUNK_TAG_PATTERN.
+    # PRE doesn't have lookback assertions, so reverse twice, and do
+    # the pattern backwards (with lookahead assertions).  This can be
+    # made much cleaner once we can switch back to SRE.
+    def reverse_str(str):
+        lst = list(str)
+        lst.reverse()
+        return "".join(lst)
+
+    tc_rev = reverse_str(ChunkString.CHUNK_TAG_CHAR)
+    reversed = reverse_str(tag_pattern)
+    reversed = re.sub(r"\.(?!\\(\\\\)*($|[^\\]))", tc_rev, reversed)
+    tag_pattern = reverse_str(reversed)
+
+    return tag_pattern
+
+
+# //////////////////////////////////////////////////////
+# RegexpChunkParser
+# //////////////////////////////////////////////////////
+
+
+class RegexpChunkParser(ChunkParserI):
+    """
+    A regular expression based chunk parser.  ``RegexpChunkParser`` uses a
+    sequence of "rules" to find chunks of a single type within a
+    text.  The chunking of the text is encoded using a ``ChunkString``,
+    and each rule acts by modifying the chunking in the
+    ``ChunkString``.  The rules are all implemented using regular
+    expression matching and substitution.
+
+    The ``RegexpChunkRule`` class and its subclasses (``ChunkRule``,
+    ``StripRule``, ``UnChunkRule``, ``MergeRule``, and ``SplitRule``)
+    define the rules that are used by ``RegexpChunkParser``.  Each rule
+    defines an ``apply()`` method, which modifies the chunking encoded
+    by a given ``ChunkString``.
+
+    :type _rules: list(RegexpChunkRule)
+    :ivar _rules: The list of rules that should be applied to a text.
+    :type _trace: int
+    :ivar _trace: The default level of tracing.
+
+    """
+
+    def __init__(self, rules, chunk_label="NP", root_label="S", trace=0):
+        """
+        Construct a new ``RegexpChunkParser``.
+
+        :type rules: list(RegexpChunkRule)
+        :param rules: The sequence of rules that should be used to
+            generate the chunking for a tagged text.
+        :type chunk_label: str
+        :param chunk_label: The node value that should be used for
+            chunk subtrees.  This is typically a short string
+            describing the type of information contained by the chunk,
+            such as ``"NP"`` for base noun phrases.
+        :type root_label: str
+        :param root_label: The node value that should be used for the
+            top node of the chunk structure.
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            ``1`` will generate normal tracing output; and ``2`` or
+            higher will generate verbose tracing output.
+        """
+        self._rules = rules
+        self._trace = trace
+        self._chunk_label = chunk_label
+        self._root_label = root_label
+
+    def _trace_apply(self, chunkstr, verbose):
+        """
+        Apply each rule of this ``RegexpChunkParser`` to ``chunkstr``, in
+        turn.  Generate trace output between each rule.  If ``verbose``
+        is true, then generate verbose output.
+
+        :type chunkstr: ChunkString
+        :param chunkstr: The chunk string to which each rule should be
+            applied.
+        :type verbose: bool
+        :param verbose: Whether output should be verbose.
+        :rtype: None
+        """
+        print("# Input:")
+        print(chunkstr)
+        for rule in self._rules:
+            rule.apply(chunkstr)
+            if verbose:
+                print("#", rule.descr() + " (" + repr(rule) + "):")
+            else:
+                print("#", rule.descr() + ":")
+            print(chunkstr)
+
+    def _notrace_apply(self, chunkstr):
+        """
+        Apply each rule of this ``RegexpChunkParser`` to ``chunkstr``, in
+        turn.
+
+        :param chunkstr: The chunk string to which each rule should be
+            applied.
+        :type chunkstr: ChunkString
+        :rtype: None
+        """
+
+        for rule in self._rules:
+            rule.apply(chunkstr)
+
+    def parse(self, chunk_struct, trace=None):
+        """
+        :type chunk_struct: Tree
+        :param chunk_struct: the chunk structure to be (further) chunked
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            ``1`` will generate normal tracing output; and ``2`` or
+            higher will generate verbose tracing output.  This value
+            overrides the trace level value that was given to the
+            constructor.
+        :rtype: Tree
+        :return: a chunk structure that encodes the chunks in a given
+            tagged sentence.  A chunk is a non-overlapping linguistic
+            group, such as a noun phrase.  The set of chunks
+            identified in the chunk structure depends on the rules
+            used to define this ``RegexpChunkParser``.
+        """
+        if len(chunk_struct) == 0:
+            print("Warning: parsing empty text")
+            return Tree(self._root_label, [])
+
+        try:
+            chunk_struct.label()
+        except AttributeError:
+            chunk_struct = Tree(self._root_label, chunk_struct)
+
+        # Use the default trace value?
+        if trace is None:
+            trace = self._trace
+
+        chunkstr = ChunkString(chunk_struct)
+
+        # Apply the sequence of rules to the chunkstring.
+        if trace:
+            verbose = trace > 1
+            self._trace_apply(chunkstr, verbose)
+        else:
+            self._notrace_apply(chunkstr)
+
+        # Use the chunkstring to create a chunk structure.
+        return chunkstr.to_chunkstruct(self._chunk_label)
+
+    def rules(self):
+        """
+        :return: the sequence of rules used by ``RegexpChunkParser``.
+        :rtype: list(RegexpChunkRule)
+        """
+        return self._rules
+
+    def __repr__(self):
+        """
+        :return: a concise string representation of this
+            ``RegexpChunkParser``.
+        :rtype: str
+        """
+        return "<RegexpChunkParser with %d rules>" % len(self._rules)
+
+    def __str__(self):
+        """
+        :return: a verbose string representation of this ``RegexpChunkParser``.
+        :rtype: str
+        """
+        s = "RegexpChunkParser with %d rules:\n" % len(self._rules)
+        margin = 0
+        for rule in self._rules:
+            margin = max(margin, len(rule.descr()))
+        if margin < 35:
+            format = "    %" + repr(-(margin + 3)) + "s%s\n"
+        else:
+            format = "    %s\n      %s\n"
+        for rule in self._rules:
+            s += format % (rule.descr(), repr(rule))
+        return s[:-1]
+
+
+# //////////////////////////////////////////////////////
+# Chunk Grammar
+# //////////////////////////////////////////////////////
+
+
+class RegexpParser(ChunkParserI):
+    r"""
+    A grammar based chunk parser.  ``chunk.RegexpParser`` uses a set of
+    regular expression patterns to specify the behavior of the parser.
+    The chunking of the text is encoded using a ``ChunkString``, and
+    each rule acts by modifying the chunking in the ``ChunkString``.
+    The rules are all implemented using regular expression matching
+    and substitution.
+
+    A grammar contains one or more clauses in the following form::
+
+     NP:
+       {<DT|JJ>}          # chunk determiners and adjectives
+       }<[\.VI].*>+{      # strip any tag beginning with V, I, or .
+       <.*>}{<DT>         # split a chunk at a determiner
+       <DT|JJ>{}<NN.*>    # merge chunk ending with det/adj
+                          # with one starting with a noun
+
+    The patterns of a clause are executed in order.  An earlier
+    pattern may introduce a chunk boundary that prevents a later
+    pattern from executing.  Sometimes an individual pattern will
+    match on multiple, overlapping extents of the input.  As with
+    regular expression substitution more generally, the chunker will
+    identify the first match possible, then continue looking for matches
+    after this one has ended.
+
+    The clauses of a grammar are also executed in order.  A cascaded
+    chunk parser is one having more than one clause.  The maximum depth
+    of a parse tree created by this chunk parser is the same as the
+    number of clauses in the grammar.
+
+    When tracing is turned on, the comment portion of a line is displayed
+    each time the corresponding pattern is applied.
+
+    :type _start: str
+    :ivar _start: The start symbol of the grammar (the root node of
+        resulting trees)
+    :type _stages: int
+    :ivar _stages: The list of parsing stages corresponding to the grammar
+
+    """
+
+    def __init__(self, grammar, root_label="S", loop=1, trace=0):
+        """
+        Create a new chunk parser, from the given start state
+        and set of chunk patterns.
+
+        :param grammar: The grammar, or a list of RegexpChunkParser objects
+        :type grammar: str or list(RegexpChunkParser)
+        :param root_label: The top node of the tree being created
+        :type root_label: str or Nonterminal
+        :param loop: The number of times to run through the patterns
+        :type loop: int
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            ``1`` will generate normal tracing output; and ``2`` or
+            higher will generate verbose tracing output.
+        """
+        self._trace = trace
+        self._stages = []
+        self._grammar = grammar
+        self._loop = loop
+
+        if isinstance(grammar, str):
+            self._read_grammar(grammar, root_label, trace)
+        else:
+            # Make sur the grammar looks like it has the right type:
+            type_err = (
+                "Expected string or list of RegexpChunkParsers " "for the grammar."
+            )
+            try:
+                grammar = list(grammar)
+            except BaseException as e:
+                raise TypeError(type_err) from e
+            for elt in grammar:
+                if not isinstance(elt, RegexpChunkParser):
+                    raise TypeError(type_err)
+            self._stages = grammar
+
+    def _read_grammar(self, grammar, root_label, trace):
+        """
+        Helper function for __init__: read the grammar if it is a
+        string.
+        """
+        rules = []
+        lhs = None
+        pattern = regex.compile("(?P<nonterminal>(\\.|[^:])*)(:(?P<rule>.*))")
+        for line in grammar.split("\n"):
+            line = line.strip()
+
+            # New stage begins if there's an unescaped ':'
+            m = pattern.match(line)
+            if m:
+                # Record the stage that we just completed.
+                self._add_stage(rules, lhs, root_label, trace)
+                # Start a new stage.
+                lhs = m.group("nonterminal").strip()
+                rules = []
+                line = m.group("rule").strip()
+
+            # Skip blank & comment-only lines
+            if line == "" or line.startswith("#"):
+                continue
+
+            # Add the rule
+            rules.append(RegexpChunkRule.fromstring(line))
+
+        # Record the final stage
+        self._add_stage(rules, lhs, root_label, trace)
+
+    def _add_stage(self, rules, lhs, root_label, trace):
+        """
+        Helper function for __init__: add a new stage to the parser.
+        """
+        if rules != []:
+            if not lhs:
+                raise ValueError("Expected stage marker (eg NP:)")
+            parser = RegexpChunkParser(
+                rules, chunk_label=lhs, root_label=root_label, trace=trace
+            )
+            self._stages.append(parser)
+
+    def parse(self, chunk_struct, trace=None):
+        """
+        Apply the chunk parser to this input.
+
+        :type chunk_struct: Tree
+        :param chunk_struct: the chunk structure to be (further) chunked
+            (this tree is modified, and is also returned)
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            ``1`` will generate normal tracing output; and ``2`` or
+            higher will generate verbose tracing output.  This value
+            overrides the trace level value that was given to the
+            constructor.
+        :return: the chunked output.
+        :rtype: Tree
+        """
+        if trace is None:
+            trace = self._trace
+        for i in range(self._loop):
+            for parser in self._stages:
+                chunk_struct = parser.parse(chunk_struct, trace=trace)
+        return chunk_struct
+
+    def __repr__(self):
+        """
+        :return: a concise string representation of this ``chunk.RegexpParser``.
+        :rtype: str
+        """
+        return "<chunk.RegexpParser with %d stages>" % len(self._stages)
+
+    def __str__(self):
+        """
+        :return: a verbose string representation of this
+            ``RegexpParser``.
+        :rtype: str
+        """
+        s = "chunk.RegexpParser with %d stages:\n" % len(self._stages)
+        margin = 0
+        for parser in self._stages:
+            s += "%s\n" % parser
+        return s[:-1]
+
+
+# //////////////////////////////////////////////////////
+# Demonstration code
+# //////////////////////////////////////////////////////
+
+
+def demo_eval(chunkparser, text):
+    """
+    Demonstration code for evaluating a chunk parser, using a
+    ``ChunkScore``.  This function assumes that ``text`` contains one
+    sentence per line, and that each sentence has the form expected by
+    ``tree.chunk``.  It runs the given chunk parser on each sentence in
+    the text, and scores the result.  It prints the final score
+    (precision, recall, and f-measure); and reports the set of chunks
+    that were missed and the set of chunks that were incorrect.  (At
+    most 10 missing chunks and 10 incorrect chunks are reported).
+
+    :param chunkparser: The chunkparser to be tested
+    :type chunkparser: ChunkParserI
+    :param text: The chunked tagged text that should be used for
+        evaluation.
+    :type text: str
+    """
+    from nltk import chunk
+    from nltk.tree import Tree
+
+    # Evaluate our chunk parser.
+    chunkscore = chunk.ChunkScore()
+
+    for sentence in text.split("\n"):
+        print(sentence)
+        sentence = sentence.strip()
+        if not sentence:
+            continue
+        gold = chunk.tagstr2tree(sentence)
+        tokens = gold.leaves()
+        test = chunkparser.parse(Tree("S", tokens), trace=1)
+        chunkscore.score(gold, test)
+        print()
+
+    print("/" + ("=" * 75) + "\\")
+    print("Scoring", chunkparser)
+    print("-" * 77)
+    print("Precision: %5.1f%%" % (chunkscore.precision() * 100), " " * 4, end=" ")
+    print("Recall: %5.1f%%" % (chunkscore.recall() * 100), " " * 6, end=" ")
+    print("F-Measure: %5.1f%%" % (chunkscore.f_measure() * 100))
+
+    # Missed chunks.
+    if chunkscore.missed():
+        print("Missed:")
+        missed = chunkscore.missed()
+        for chunk in missed[:10]:
+            print("  ", " ".join(map(str, chunk)))
+        if len(chunkscore.missed()) > 10:
+            print("  ...")
+
+    # Incorrect chunks.
+    if chunkscore.incorrect():
+        print("Incorrect:")
+        incorrect = chunkscore.incorrect()
+        for chunk in incorrect[:10]:
+            print("  ", " ".join(map(str, chunk)))
+        if len(chunkscore.incorrect()) > 10:
+            print("  ...")
+
+    print("\\" + ("=" * 75) + "/")
+    print()
+
+
+def demo():
+    """
+    A demonstration for the ``RegexpChunkParser`` class.  A single text is
+    parsed with four different chunk parsers, using a variety of rules
+    and strategies.
+    """
+
+    from nltk import Tree, chunk
+
+    text = """\
+    [ the/DT little/JJ cat/NN ] sat/VBD on/IN [ the/DT mat/NN ] ./.
+    [ John/NNP ] saw/VBD [the/DT cats/NNS] [the/DT dog/NN] chased/VBD ./.
+    [ John/NNP ] thinks/VBZ [ Mary/NN ] saw/VBD [ the/DT cat/NN ] sit/VB on/IN [ the/DT mat/NN ]./.
+    """
+
+    print("*" * 75)
+    print("Evaluation text:")
+    print(text)
+    print("*" * 75)
+    print()
+
+    grammar = r"""
+    NP:                   # NP stage
+      {<DT>?<JJ>*<NN>}    # chunk determiners, adjectives and nouns
+      {<NNP>+}            # chunk proper nouns
+    """
+    cp = chunk.RegexpParser(grammar)
+    demo_eval(cp, text)
+
+    grammar = r"""
+    NP:
+      {<.*>}              # start by chunking each tag
+      }<[\.VI].*>+{       # unchunk any verbs, prepositions or periods
+      <DT|JJ>{}<NN.*>     # merge det/adj with nouns
+    """
+    cp = chunk.RegexpParser(grammar)
+    demo_eval(cp, text)
+
+    grammar = r"""
+    NP: {<DT>?<JJ>*<NN>}    # chunk determiners, adjectives and nouns
+    VP: {<TO>?<VB.*>}       # VP = verb words
+    """
+    cp = chunk.RegexpParser(grammar)
+    demo_eval(cp, text)
+
+    grammar = r"""
+    NP: {<.*>*}             # start by chunking everything
+        }<[\.VI].*>+{       # strip any verbs, prepositions or periods
+        <.*>}{<DT>          # separate on determiners
+    PP: {<IN><NP>}          # PP = preposition + noun phrase
+    VP: {<VB.*><NP|PP>*}    # VP = verb words + NPs and PPs
+    """
+    cp = chunk.RegexpParser(grammar)
+    demo_eval(cp, text)
+
+    # Evaluation
+
+    from nltk.corpus import conll2000
+
+    print()
+    print("Demonstration of empty grammar:")
+
+    cp = chunk.RegexpParser("")
+    print(chunk.accuracy(cp, conll2000.chunked_sents("test.txt", chunk_types=("NP",))))
+
+    print()
+    print("Demonstration of accuracy evaluation using CoNLL tags:")
+
+    grammar = r"""
+    NP:
+      {<.*>}              # start by chunking each tag
+      }<[\.VI].*>+{       # unchunk any verbs, prepositions or periods
+      <DT|JJ>{}<NN.*>     # merge det/adj with nouns
+    """
+    cp = chunk.RegexpParser(grammar)
+    print(chunk.accuracy(cp, conll2000.chunked_sents("test.txt")[:5]))
+
+    print()
+    print("Demonstration of tagged token input")
+
+    grammar = r"""
+    NP: {<.*>*}             # start by chunking everything
+        }<[\.VI].*>+{       # strip any verbs, prepositions or periods
+        <.*>}{<DT>          # separate on determiners
+    PP: {<IN><NP>}          # PP = preposition + noun phrase
+    VP: {<VB.*><NP|PP>*}    # VP = verb words + NPs and PPs
+    """
+    cp = chunk.RegexpParser(grammar)
+    print(
+        cp.parse(
+            [
+                ("the", "DT"),
+                ("little", "JJ"),
+                ("cat", "NN"),
+                ("sat", "VBD"),
+                ("on", "IN"),
+                ("the", "DT"),
+                ("mat", "NN"),
+                (".", "."),
+            ]
+        )
+    )
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/chunk/util.py

@@ -0,0 +1,643 @@
+# Natural Language Toolkit: Chunk format conversions
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]> (minor additions)
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import re
+
+from nltk.metrics import accuracy as _accuracy
+from nltk.tag.mapping import map_tag
+from nltk.tag.util import str2tuple
+from nltk.tree import Tree
+
+##//////////////////////////////////////////////////////
+## EVALUATION
+##//////////////////////////////////////////////////////
+
+
+def accuracy(chunker, gold):
+    """
+    Score the accuracy of the chunker against the gold standard.
+    Strip the chunk information from the gold standard and rechunk it using
+    the chunker, then compute the accuracy score.
+
+    :type chunker: ChunkParserI
+    :param chunker: The chunker being evaluated.
+    :type gold: tree
+    :param gold: The chunk structures to score the chunker on.
+    :rtype: float
+    """
+
+    gold_tags = []
+    test_tags = []
+    for gold_tree in gold:
+        test_tree = chunker.parse(gold_tree.flatten())
+        gold_tags += tree2conlltags(gold_tree)
+        test_tags += tree2conlltags(test_tree)
+
+    #    print 'GOLD:', gold_tags[:50]
+    #    print 'TEST:', test_tags[:50]
+    return _accuracy(gold_tags, test_tags)
+
+
+# Patched for increased performance by Yoav Goldberg <[email protected]>, 2006-01-13
+#  -- statistics are evaluated only on demand, instead of at every sentence evaluation
+#
+# SB: use nltk.metrics for precision/recall scoring?
+#
+class ChunkScore:
+    """
+    A utility class for scoring chunk parsers.  ``ChunkScore`` can
+    evaluate a chunk parser's output, based on a number of statistics
+    (precision, recall, f-measure, misssed chunks, incorrect chunks).
+    It can also combine the scores from the parsing of multiple texts;
+    this makes it significantly easier to evaluate a chunk parser that
+    operates one sentence at a time.
+
+    Texts are evaluated with the ``score`` method.  The results of
+    evaluation can be accessed via a number of accessor methods, such
+    as ``precision`` and ``f_measure``.  A typical use of the
+    ``ChunkScore`` class is::
+
+        >>> chunkscore = ChunkScore()           # doctest: +SKIP
+        >>> for correct in correct_sentences:   # doctest: +SKIP
+        ...     guess = chunkparser.parse(correct.leaves())   # doctest: +SKIP
+        ...     chunkscore.score(correct, guess)              # doctest: +SKIP
+        >>> print('F Measure:', chunkscore.f_measure())       # doctest: +SKIP
+        F Measure: 0.823
+
+    :ivar kwargs: Keyword arguments:
+
+        - max_tp_examples: The maximum number actual examples of true
+          positives to record.  This affects the ``correct`` member
+          function: ``correct`` will not return more than this number
+          of true positive examples.  This does *not* affect any of
+          the numerical metrics (precision, recall, or f-measure)
+
+        - max_fp_examples: The maximum number actual examples of false
+          positives to record.  This affects the ``incorrect`` member
+          function and the ``guessed`` member function: ``incorrect``
+          will not return more than this number of examples, and
+          ``guessed`` will not return more than this number of true
+          positive examples.  This does *not* affect any of the
+          numerical metrics (precision, recall, or f-measure)
+
+        - max_fn_examples: The maximum number actual examples of false
+          negatives to record.  This affects the ``missed`` member
+          function and the ``correct`` member function: ``missed``
+          will not return more than this number of examples, and
+          ``correct`` will not return more than this number of true
+          negative examples.  This does *not* affect any of the
+          numerical metrics (precision, recall, or f-measure)
+
+        - chunk_label: A regular expression indicating which chunks
+          should be compared.  Defaults to ``'.*'`` (i.e., all chunks).
+
+    :type _tp: list(Token)
+    :ivar _tp: List of true positives
+    :type _fp: list(Token)
+    :ivar _fp: List of false positives
+    :type _fn: list(Token)
+    :ivar _fn: List of false negatives
+
+    :type _tp_num: int
+    :ivar _tp_num: Number of true positives
+    :type _fp_num: int
+    :ivar _fp_num: Number of false positives
+    :type _fn_num: int
+    :ivar _fn_num: Number of false negatives.
+    """
+
+    def __init__(self, **kwargs):
+        self._correct = set()
+        self._guessed = set()
+        self._tp = set()
+        self._fp = set()
+        self._fn = set()
+        self._max_tp = kwargs.get("max_tp_examples", 100)
+        self._max_fp = kwargs.get("max_fp_examples", 100)
+        self._max_fn = kwargs.get("max_fn_examples", 100)
+        self._chunk_label = kwargs.get("chunk_label", ".*")
+        self._tp_num = 0
+        self._fp_num = 0
+        self._fn_num = 0
+        self._count = 0
+        self._tags_correct = 0.0
+        self._tags_total = 0.0
+
+        self._measuresNeedUpdate = False
+
+    def _updateMeasures(self):
+        if self._measuresNeedUpdate:
+            self._tp = self._guessed & self._correct
+            self._fn = self._correct - self._guessed
+            self._fp = self._guessed - self._correct
+            self._tp_num = len(self._tp)
+            self._fp_num = len(self._fp)
+            self._fn_num = len(self._fn)
+            self._measuresNeedUpdate = False
+
+    def score(self, correct, guessed):
+        """
+        Given a correctly chunked sentence, score another chunked
+        version of the same sentence.
+
+        :type correct: chunk structure
+        :param correct: The known-correct ("gold standard") chunked
+            sentence.
+        :type guessed: chunk structure
+        :param guessed: The chunked sentence to be scored.
+        """
+        self._correct |= _chunksets(correct, self._count, self._chunk_label)
+        self._guessed |= _chunksets(guessed, self._count, self._chunk_label)
+        self._count += 1
+        self._measuresNeedUpdate = True
+        # Keep track of per-tag accuracy (if possible)
+        try:
+            correct_tags = tree2conlltags(correct)
+            guessed_tags = tree2conlltags(guessed)
+        except ValueError:
+            # This exception case is for nested chunk structures,
+            # where tree2conlltags will fail with a ValueError: "Tree
+            # is too deeply nested to be printed in CoNLL format."
+            correct_tags = guessed_tags = ()
+        self._tags_total += len(correct_tags)
+        self._tags_correct += sum(
+            1 for (t, g) in zip(guessed_tags, correct_tags) if t == g
+        )
+
+    def accuracy(self):
+        """
+        Return the overall tag-based accuracy for all text that have
+        been scored by this ``ChunkScore``, using the IOB (conll2000)
+        tag encoding.
+
+        :rtype: float
+        """
+        if self._tags_total == 0:
+            return 1
+        return self._tags_correct / self._tags_total
+
+    def precision(self):
+        """
+        Return the overall precision for all texts that have been
+        scored by this ``ChunkScore``.
+
+        :rtype: float
+        """
+        self._updateMeasures()
+        div = self._tp_num + self._fp_num
+        if div == 0:
+            return 0
+        else:
+            return self._tp_num / div
+
+    def recall(self):
+        """
+        Return the overall recall for all texts that have been
+        scored by this ``ChunkScore``.
+
+        :rtype: float
+        """
+        self._updateMeasures()
+        div = self._tp_num + self._fn_num
+        if div == 0:
+            return 0
+        else:
+            return self._tp_num / div
+
+    def f_measure(self, alpha=0.5):
+        """
+        Return the overall F measure for all texts that have been
+        scored by this ``ChunkScore``.
+
+        :param alpha: the relative weighting of precision and recall.
+            Larger alpha biases the score towards the precision value,
+            while smaller alpha biases the score towards the recall
+            value.  ``alpha`` should have a value in the range [0,1].
+        :type alpha: float
+        :rtype: float
+        """
+        self._updateMeasures()
+        p = self.precision()
+        r = self.recall()
+        if p == 0 or r == 0:  # what if alpha is 0 or 1?
+            return 0
+        return 1 / (alpha / p + (1 - alpha) / r)
+
+    def missed(self):
+        """
+        Return the chunks which were included in the
+        correct chunk structures, but not in the guessed chunk
+        structures, listed in input order.
+
+        :rtype: list of chunks
+        """
+        self._updateMeasures()
+        chunks = list(self._fn)
+        return [c[1] for c in chunks]  # discard position information
+
+    def incorrect(self):
+        """
+        Return the chunks which were included in the guessed chunk structures,
+        but not in the correct chunk structures, listed in input order.
+
+        :rtype: list of chunks
+        """
+        self._updateMeasures()
+        chunks = list(self._fp)
+        return [c[1] for c in chunks]  # discard position information
+
+    def correct(self):
+        """
+        Return the chunks which were included in the correct
+        chunk structures, listed in input order.
+
+        :rtype: list of chunks
+        """
+        chunks = list(self._correct)
+        return [c[1] for c in chunks]  # discard position information
+
+    def guessed(self):
+        """
+        Return the chunks which were included in the guessed
+        chunk structures, listed in input order.
+
+        :rtype: list of chunks
+        """
+        chunks = list(self._guessed)
+        return [c[1] for c in chunks]  # discard position information
+
+    def __len__(self):
+        self._updateMeasures()
+        return self._tp_num + self._fn_num
+
+    def __repr__(self):
+        """
+        Return a concise representation of this ``ChunkScoring``.
+
+        :rtype: str
+        """
+        return "<ChunkScoring of " + repr(len(self)) + " chunks>"
+
+    def __str__(self):
+        """
+        Return a verbose representation of this ``ChunkScoring``.
+        This representation includes the precision, recall, and
+        f-measure scores.  For other information about the score,
+        use the accessor methods (e.g., ``missed()`` and ``incorrect()``).
+
+        :rtype: str
+        """
+        return (
+            "ChunkParse score:\n"
+            + (f"    IOB Accuracy: {self.accuracy() * 100:5.1f}%%\n")
+            + (f"    Precision:    {self.precision() * 100:5.1f}%%\n")
+            + (f"    Recall:       {self.recall() * 100:5.1f}%%\n")
+            + (f"    F-Measure:    {self.f_measure() * 100:5.1f}%%")
+        )
+
+
+# extract chunks, and assign unique id, the absolute position of
+# the first word of the chunk
+def _chunksets(t, count, chunk_label):
+    pos = 0
+    chunks = []
+    for child in t:
+        if isinstance(child, Tree):
+            if re.match(chunk_label, child.label()):
+                chunks.append(((count, pos), child.freeze()))
+            pos += len(child.leaves())
+        else:
+            pos += 1
+    return set(chunks)
+
+
+def tagstr2tree(
+    s, chunk_label="NP", root_label="S", sep="/", source_tagset=None, target_tagset=None
+):
+    """
+    Divide a string of bracketted tagged text into
+    chunks and unchunked tokens, and produce a Tree.
+    Chunks are marked by square brackets (``[...]``).  Words are
+    delimited by whitespace, and each word should have the form
+    ``text/tag``.  Words that do not contain a slash are
+    assigned a ``tag`` of None.
+
+    :param s: The string to be converted
+    :type s: str
+    :param chunk_label: The label to use for chunk nodes
+    :type chunk_label: str
+    :param root_label: The label to use for the root of the tree
+    :type root_label: str
+    :rtype: Tree
+    """
+
+    WORD_OR_BRACKET = re.compile(r"\[|\]|[^\[\]\s]+")
+
+    stack = [Tree(root_label, [])]
+    for match in WORD_OR_BRACKET.finditer(s):
+        text = match.group()
+        if text[0] == "[":
+            if len(stack) != 1:
+                raise ValueError(f"Unexpected [ at char {match.start():d}")
+            chunk = Tree(chunk_label, [])
+            stack[-1].append(chunk)
+            stack.append(chunk)
+        elif text[0] == "]":
+            if len(stack) != 2:
+                raise ValueError(f"Unexpected ] at char {match.start():d}")
+            stack.pop()
+        else:
+            if sep is None:
+                stack[-1].append(text)
+            else:
+                word, tag = str2tuple(text, sep)
+                if source_tagset and target_tagset:
+                    tag = map_tag(source_tagset, target_tagset, tag)
+                stack[-1].append((word, tag))
+
+    if len(stack) != 1:
+        raise ValueError(f"Expected ] at char {len(s):d}")
+    return stack[0]
+
+
+### CONLL
+
+_LINE_RE = re.compile(r"(\S+)\s+(\S+)\s+([IOB])-?(\S+)?")
+
+
+def conllstr2tree(s, chunk_types=("NP", "PP", "VP"), root_label="S"):
+    """
+    Return a chunk structure for a single sentence
+    encoded in the given CONLL 2000 style string.
+    This function converts a CoNLL IOB string into a tree.
+    It uses the specified chunk types
+    (defaults to NP, PP and VP), and creates a tree rooted at a node
+    labeled S (by default).
+
+    :param s: The CoNLL string to be converted.
+    :type s: str
+    :param chunk_types: The chunk types to be converted.
+    :type chunk_types: tuple
+    :param root_label: The node label to use for the root.
+    :type root_label: str
+    :rtype: Tree
+    """
+
+    stack = [Tree(root_label, [])]
+
+    for lineno, line in enumerate(s.split("\n")):
+        if not line.strip():
+            continue
+
+        # Decode the line.
+        match = _LINE_RE.match(line)
+        if match is None:
+            raise ValueError(f"Error on line {lineno:d}")
+        (word, tag, state, chunk_type) = match.groups()
+
+        # If it's a chunk type we don't care about, treat it as O.
+        if chunk_types is not None and chunk_type not in chunk_types:
+            state = "O"
+
+        # For "Begin"/"Outside", finish any completed chunks -
+        # also do so for "Inside" which don't match the previous token.
+        mismatch_I = state == "I" and chunk_type != stack[-1].label()
+        if state in "BO" or mismatch_I:
+            if len(stack) == 2:
+                stack.pop()
+
+        # For "Begin", start a new chunk.
+        if state == "B" or mismatch_I:
+            chunk = Tree(chunk_type, [])
+            stack[-1].append(chunk)
+            stack.append(chunk)
+
+        # Add the new word token.
+        stack[-1].append((word, tag))
+
+    return stack[0]
+
+
+def tree2conlltags(t):
+    """
+    Return a list of 3-tuples containing ``(word, tag, IOB-tag)``.
+    Convert a tree to the CoNLL IOB tag format.
+
+    :param t: The tree to be converted.
+    :type t: Tree
+    :rtype: list(tuple)
+    """
+
+    tags = []
+    for child in t:
+        try:
+            category = child.label()
+            prefix = "B-"
+            for contents in child:
+                if isinstance(contents, Tree):
+                    raise ValueError(
+                        "Tree is too deeply nested to be printed in CoNLL format"
+                    )
+                tags.append((contents[0], contents[1], prefix + category))
+                prefix = "I-"
+        except AttributeError:
+            tags.append((child[0], child[1], "O"))
+    return tags
+
+
+def conlltags2tree(
+    sentence, chunk_types=("NP", "PP", "VP"), root_label="S", strict=False
+):
+    """
+    Convert the CoNLL IOB format to a tree.
+    """
+    tree = Tree(root_label, [])
+    for (word, postag, chunktag) in sentence:
+        if chunktag is None:
+            if strict:
+                raise ValueError("Bad conll tag sequence")
+            else:
+                # Treat as O
+                tree.append((word, postag))
+        elif chunktag.startswith("B-"):
+            tree.append(Tree(chunktag[2:], [(word, postag)]))
+        elif chunktag.startswith("I-"):
+            if (
+                len(tree) == 0
+                or not isinstance(tree[-1], Tree)
+                or tree[-1].label() != chunktag[2:]
+            ):
+                if strict:
+                    raise ValueError("Bad conll tag sequence")
+                else:
+                    # Treat as B-*
+                    tree.append(Tree(chunktag[2:], [(word, postag)]))
+            else:
+                tree[-1].append((word, postag))
+        elif chunktag == "O":
+            tree.append((word, postag))
+        else:
+            raise ValueError(f"Bad conll tag {chunktag!r}")
+    return tree
+
+
+def tree2conllstr(t):
+    """
+    Return a multiline string where each line contains a word, tag and IOB tag.
+    Convert a tree to the CoNLL IOB string format
+
+    :param t: The tree to be converted.
+    :type t: Tree
+    :rtype: str
+    """
+    lines = [" ".join(token) for token in tree2conlltags(t)]
+    return "\n".join(lines)
+
+
+### IEER
+
+_IEER_DOC_RE = re.compile(
+    r"<DOC>\s*"
+    r"(<DOCNO>\s*(?P<docno>.+?)\s*</DOCNO>\s*)?"
+    r"(<DOCTYPE>\s*(?P<doctype>.+?)\s*</DOCTYPE>\s*)?"
+    r"(<DATE_TIME>\s*(?P<date_time>.+?)\s*</DATE_TIME>\s*)?"
+    r"<BODY>\s*"
+    r"(<HEADLINE>\s*(?P<headline>.+?)\s*</HEADLINE>\s*)?"
+    r"<TEXT>(?P<text>.*?)</TEXT>\s*"
+    r"</BODY>\s*</DOC>\s*",
+    re.DOTALL,
+)
+
+_IEER_TYPE_RE = re.compile(r'<b_\w+\s+[^>]*?type="(?P<type>\w+)"')
+
+
+def _ieer_read_text(s, root_label):
+    stack = [Tree(root_label, [])]
+    # s will be None if there is no headline in the text
+    # return the empty list in place of a Tree
+    if s is None:
+        return []
+    for piece_m in re.finditer(r"<[^>]+>|[^\s<]+", s):
+        piece = piece_m.group()
+        try:
+            if piece.startswith("<b_"):
+                m = _IEER_TYPE_RE.match(piece)
+                if m is None:
+                    print("XXXX", piece)
+                chunk = Tree(m.group("type"), [])
+                stack[-1].append(chunk)
+                stack.append(chunk)
+            elif piece.startswith("<e_"):
+                stack.pop()
+            #           elif piece.startswith('<'):
+            #               print "ERROR:", piece
+            #               raise ValueError # Unexpected HTML
+            else:
+                stack[-1].append(piece)
+        except (IndexError, ValueError) as e:
+            raise ValueError(
+                f"Bad IEER string (error at character {piece_m.start():d})"
+            ) from e
+    if len(stack) != 1:
+        raise ValueError("Bad IEER string")
+    return stack[0]
+
+
+def ieerstr2tree(
+    s,
+    chunk_types=[
+        "LOCATION",
+        "ORGANIZATION",
+        "PERSON",
+        "DURATION",
+        "DATE",
+        "CARDINAL",
+        "PERCENT",
+        "MONEY",
+        "MEASURE",
+    ],
+    root_label="S",
+):
+    """
+    Return a chunk structure containing the chunked tagged text that is
+    encoded in the given IEER style string.
+    Convert a string of chunked tagged text in the IEER named
+    entity format into a chunk structure.  Chunks are of several
+    types, LOCATION, ORGANIZATION, PERSON, DURATION, DATE, CARDINAL,
+    PERCENT, MONEY, and MEASURE.
+
+    :rtype: Tree
+    """
+
+    # Try looking for a single document.  If that doesn't work, then just
+    # treat everything as if it was within the <TEXT>...</TEXT>.
+    m = _IEER_DOC_RE.match(s)
+    if m:
+        return {
+            "text": _ieer_read_text(m.group("text"), root_label),
+            "docno": m.group("docno"),
+            "doctype": m.group("doctype"),
+            "date_time": m.group("date_time"),
+            #'headline': m.group('headline')
+            # we want to capture NEs in the headline too!
+            "headline": _ieer_read_text(m.group("headline"), root_label),
+        }
+    else:
+        return _ieer_read_text(s, root_label)
+
+
+def demo():
+
+    s = "[ Pierre/NNP Vinken/NNP ] ,/, [ 61/CD years/NNS ] old/JJ ,/, will/MD join/VB [ the/DT board/NN ] ./."
+    import nltk
+
+    t = nltk.chunk.tagstr2tree(s, chunk_label="NP")
+    t.pprint()
+    print()
+
+    s = """
+These DT B-NP
+research NN I-NP
+protocols NNS I-NP
+offer VBP B-VP
+to TO B-PP
+the DT B-NP
+patient NN I-NP
+not RB O
+only RB O
+the DT B-NP
+very RB I-NP
+best JJS I-NP
+therapy NN I-NP
+which WDT B-NP
+we PRP B-NP
+have VBP B-VP
+established VBN I-VP
+today NN B-NP
+but CC B-NP
+also RB I-NP
+the DT B-NP
+hope NN I-NP
+of IN B-PP
+something NN B-NP
+still RB B-ADJP
+better JJR I-ADJP
+. . O
+"""
+
+    conll_tree = conllstr2tree(s, chunk_types=("NP", "PP"))
+    conll_tree.pprint()
+
+    # Demonstrate CoNLL output
+    print("CoNLL output:")
+    print(nltk.chunk.tree2conllstr(conll_tree))
+    print()
+
+
+if __name__ == "__main__":
+    demo()

llmeval-env/lib/python3.10/site-packages/nltk/cli.py

@@ -0,0 +1,55 @@
+# Natural Language Toolkit: NLTK Command-Line Interface
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+
+import click
+from tqdm import tqdm
+
+from nltk import word_tokenize
+from nltk.util import parallelize_preprocess
+
+CONTEXT_SETTINGS = dict(help_option_names=["-h", "--help"])
+
+
+@click.group(context_settings=CONTEXT_SETTINGS)
+@click.version_option()
+def cli():
+    pass
+
+
+@cli.command("tokenize")
+@click.option(
+    "--language",
+    "-l",
+    default="en",
+    help="The language for the Punkt sentence tokenization.",
+)
+@click.option(
+    "--preserve-line",
+    "-l",
+    default=True,
+    is_flag=True,
+    help="An option to keep the preserve the sentence and not sentence tokenize it.",
+)
+@click.option("--processes", "-j", default=1, help="No. of processes.")
+@click.option("--encoding", "-e", default="utf8", help="Specify encoding of file.")
+@click.option(
+    "--delimiter", "-d", default=" ", help="Specify delimiter to join the tokens."
+)
+def tokenize_file(language, preserve_line, processes, encoding, delimiter):
+    """This command tokenizes text stream using nltk.word_tokenize"""
+    with click.get_text_stream("stdin", encoding=encoding) as fin:
+        with click.get_text_stream("stdout", encoding=encoding) as fout:
+            # If it's single process, joblib parallelization is slower,
+            # so just process line by line normally.
+            if processes == 1:
+                for line in tqdm(fin.readlines()):
+                    print(delimiter.join(word_tokenize(line)), end="\n", file=fout)
+            else:
+                for outline in parallelize_preprocess(
+                    word_tokenize, fin.readlines(), processes, progress_bar=True
+                ):
+                    print(delimiter.join(outline), end="\n", file=fout)

llmeval-env/lib/python3.10/site-packages/nltk/collections.py

@@ -0,0 +1,661 @@
+# Natural Language Toolkit: Collections
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import bisect
+
+# this unused import is for python 2.7
+from collections import Counter, defaultdict, deque
+from functools import total_ordering
+from itertools import chain, islice
+
+from nltk.internals import raise_unorderable_types, slice_bounds
+
+##########################################################################
+# Ordered Dictionary
+##########################################################################
+
+
+class OrderedDict(dict):
+    def __init__(self, data=None, **kwargs):
+        self._keys = self.keys(data, kwargs.get("keys"))
+        self._default_factory = kwargs.get("default_factory")
+        if data is None:
+            dict.__init__(self)
+        else:
+            dict.__init__(self, data)
+
+    def __delitem__(self, key):
+        dict.__delitem__(self, key)
+        self._keys.remove(key)
+
+    def __getitem__(self, key):
+        try:
+            return dict.__getitem__(self, key)
+        except KeyError:
+            return self.__missing__(key)
+
+    def __iter__(self):
+        return (key for key in self.keys())
+
+    def __missing__(self, key):
+        if not self._default_factory and key not in self._keys:
+            raise KeyError()
+        return self._default_factory()
+
+    def __setitem__(self, key, item):
+        dict.__setitem__(self, key, item)
+        if key not in self._keys:
+            self._keys.append(key)
+
+    def clear(self):
+        dict.clear(self)
+        self._keys.clear()
+
+    def copy(self):
+        d = dict.copy(self)
+        d._keys = self._keys
+        return d
+
+    def items(self):
+        # returns iterator under python 3 and list under python 2
+        return zip(self.keys(), self.values())
+
+    def keys(self, data=None, keys=None):
+        if data:
+            if keys:
+                assert isinstance(keys, list)
+                assert len(data) == len(keys)
+                return keys
+            else:
+                assert (
+                    isinstance(data, dict)
+                    or isinstance(data, OrderedDict)
+                    or isinstance(data, list)
+                )
+                if isinstance(data, dict) or isinstance(data, OrderedDict):
+                    return data.keys()
+                elif isinstance(data, list):
+                    return [key for (key, value) in data]
+        elif "_keys" in self.__dict__:
+            return self._keys
+        else:
+            return []
+
+    def popitem(self):
+        if not self._keys:
+            raise KeyError()
+
+        key = self._keys.pop()
+        value = self[key]
+        del self[key]
+        return (key, value)
+
+    def setdefault(self, key, failobj=None):
+        dict.setdefault(self, key, failobj)
+        if key not in self._keys:
+            self._keys.append(key)
+
+    def update(self, data):
+        dict.update(self, data)
+        for key in self.keys(data):
+            if key not in self._keys:
+                self._keys.append(key)
+
+    def values(self):
+        # returns iterator under python 3
+        return map(self.get, self._keys)
+
+
+######################################################################
+# Lazy Sequences
+######################################################################
+
+
+@total_ordering
+class AbstractLazySequence:
+    """
+    An abstract base class for read-only sequences whose values are
+    computed as needed.  Lazy sequences act like tuples -- they can be
+    indexed, sliced, and iterated over; but they may not be modified.
+
+    The most common application of lazy sequences in NLTK is for
+    corpus view objects, which provide access to the contents of a
+    corpus without loading the entire corpus into memory, by loading
+    pieces of the corpus from disk as needed.
+
+    The result of modifying a mutable element of a lazy sequence is
+    undefined.  In particular, the modifications made to the element
+    may or may not persist, depending on whether and when the lazy
+    sequence caches that element's value or reconstructs it from
+    scratch.
+
+    Subclasses are required to define two methods: ``__len__()``
+    and ``iterate_from()``.
+    """
+
+    def __len__(self):
+        """
+        Return the number of tokens in the corpus file underlying this
+        corpus view.
+        """
+        raise NotImplementedError("should be implemented by subclass")
+
+    def iterate_from(self, start):
+        """
+        Return an iterator that generates the tokens in the corpus
+        file underlying this corpus view, starting at the token number
+        ``start``.  If ``start>=len(self)``, then this iterator will
+        generate no tokens.
+        """
+        raise NotImplementedError("should be implemented by subclass")
+
+    def __getitem__(self, i):
+        """
+        Return the *i* th token in the corpus file underlying this
+        corpus view.  Negative indices and spans are both supported.
+        """
+        if isinstance(i, slice):
+            start, stop = slice_bounds(self, i)
+            return LazySubsequence(self, start, stop)
+        else:
+            # Handle negative indices
+            if i < 0:
+                i += len(self)
+            if i < 0:
+                raise IndexError("index out of range")
+            # Use iterate_from to extract it.
+            try:
+                return next(self.iterate_from(i))
+            except StopIteration as e:
+                raise IndexError("index out of range") from e
+
+    def __iter__(self):
+        """Return an iterator that generates the tokens in the corpus
+        file underlying this corpus view."""
+        return self.iterate_from(0)
+
+    def count(self, value):
+        """Return the number of times this list contains ``value``."""
+        return sum(1 for elt in self if elt == value)
+
+    def index(self, value, start=None, stop=None):
+        """Return the index of the first occurrence of ``value`` in this
+        list that is greater than or equal to ``start`` and less than
+        ``stop``.  Negative start and stop values are treated like negative
+        slice bounds -- i.e., they count from the end of the list."""
+        start, stop = slice_bounds(self, slice(start, stop))
+        for i, elt in enumerate(islice(self, start, stop)):
+            if elt == value:
+                return i + start
+        raise ValueError("index(x): x not in list")
+
+    def __contains__(self, value):
+        """Return true if this list contains ``value``."""
+        return bool(self.count(value))
+
+    def __add__(self, other):
+        """Return a list concatenating self with other."""
+        return LazyConcatenation([self, other])
+
+    def __radd__(self, other):
+        """Return a list concatenating other with self."""
+        return LazyConcatenation([other, self])
+
+    def __mul__(self, count):
+        """Return a list concatenating self with itself ``count`` times."""
+        return LazyConcatenation([self] * count)
+
+    def __rmul__(self, count):
+        """Return a list concatenating self with itself ``count`` times."""
+        return LazyConcatenation([self] * count)
+
+    _MAX_REPR_SIZE = 60
+
+    def __repr__(self):
+        """
+        Return a string representation for this corpus view that is
+        similar to a list's representation; but if it would be more
+        than 60 characters long, it is truncated.
+        """
+        pieces = []
+        length = 5
+        for elt in self:
+            pieces.append(repr(elt))
+            length += len(pieces[-1]) + 2
+            if length > self._MAX_REPR_SIZE and len(pieces) > 2:
+                return "[%s, ...]" % ", ".join(pieces[:-1])
+        return "[%s]" % ", ".join(pieces)
+
+    def __eq__(self, other):
+        return type(self) == type(other) and list(self) == list(other)
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if type(other) != type(self):
+            raise_unorderable_types("<", self, other)
+        return list(self) < list(other)
+
+    def __hash__(self):
+        """
+        :raise ValueError: Corpus view objects are unhashable.
+        """
+        raise ValueError("%s objects are unhashable" % self.__class__.__name__)
+
+
+class LazySubsequence(AbstractLazySequence):
+    """
+    A subsequence produced by slicing a lazy sequence.  This slice
+    keeps a reference to its source sequence, and generates its values
+    by looking them up in the source sequence.
+    """
+
+    MIN_SIZE = 100
+    """
+    The minimum size for which lazy slices should be created.  If
+    ``LazySubsequence()`` is called with a subsequence that is
+    shorter than ``MIN_SIZE``, then a tuple will be returned instead.
+    """
+
+    def __new__(cls, source, start, stop):
+        """
+        Construct a new slice from a given underlying sequence.  The
+        ``start`` and ``stop`` indices should be absolute indices --
+        i.e., they should not be negative (for indexing from the back
+        of a list) or greater than the length of ``source``.
+        """
+        # If the slice is small enough, just use a tuple.
+        if stop - start < cls.MIN_SIZE:
+            return list(islice(source.iterate_from(start), stop - start))
+        else:
+            return object.__new__(cls)
+
+    def __init__(self, source, start, stop):
+        self._source = source
+        self._start = start
+        self._stop = stop
+
+    def __len__(self):
+        return self._stop - self._start
+
+    def iterate_from(self, start):
+        return islice(
+            self._source.iterate_from(start + self._start), max(0, len(self) - start)
+        )
+
+
+class LazyConcatenation(AbstractLazySequence):
+    """
+    A lazy sequence formed by concatenating a list of lists.  This
+    underlying list of lists may itself be lazy.  ``LazyConcatenation``
+    maintains an index that it uses to keep track of the relationship
+    between offsets in the concatenated lists and offsets in the
+    sublists.
+    """
+
+    def __init__(self, list_of_lists):
+        self._list = list_of_lists
+        self._offsets = [0]
+
+    def __len__(self):
+        if len(self._offsets) <= len(self._list):
+            for _ in self.iterate_from(self._offsets[-1]):
+                pass
+        return self._offsets[-1]
+
+    def iterate_from(self, start_index):
+        if start_index < self._offsets[-1]:
+            sublist_index = bisect.bisect_right(self._offsets, start_index) - 1
+        else:
+            sublist_index = len(self._offsets) - 1
+
+        index = self._offsets[sublist_index]
+
+        # Construct an iterator over the sublists.
+        if isinstance(self._list, AbstractLazySequence):
+            sublist_iter = self._list.iterate_from(sublist_index)
+        else:
+            sublist_iter = islice(self._list, sublist_index, None)
+
+        for sublist in sublist_iter:
+            if sublist_index == (len(self._offsets) - 1):
+                assert (
+                    index + len(sublist) >= self._offsets[-1]
+                ), "offsets not monotonic increasing!"
+                self._offsets.append(index + len(sublist))
+            else:
+                assert self._offsets[sublist_index + 1] == index + len(
+                    sublist
+                ), "inconsistent list value (num elts)"
+
+            yield from sublist[max(0, start_index - index) :]
+
+            index += len(sublist)
+            sublist_index += 1
+
+
+class LazyMap(AbstractLazySequence):
+    """
+    A lazy sequence whose elements are formed by applying a given
+    function to each element in one or more underlying lists.  The
+    function is applied lazily -- i.e., when you read a value from the
+    list, ``LazyMap`` will calculate that value by applying its
+    function to the underlying lists' value(s).  ``LazyMap`` is
+    essentially a lazy version of the Python primitive function
+    ``map``.  In particular, the following two expressions are
+    equivalent:
+
+        >>> from nltk.collections import LazyMap
+        >>> function = str
+        >>> sequence = [1,2,3]
+        >>> map(function, sequence) # doctest: +SKIP
+        ['1', '2', '3']
+        >>> list(LazyMap(function, sequence))
+        ['1', '2', '3']
+
+    Like the Python ``map`` primitive, if the source lists do not have
+    equal size, then the value None will be supplied for the
+    'missing' elements.
+
+    Lazy maps can be useful for conserving memory, in cases where
+    individual values take up a lot of space.  This is especially true
+    if the underlying list's values are constructed lazily, as is the
+    case with many corpus readers.
+
+    A typical example of a use case for this class is performing
+    feature detection on the tokens in a corpus.  Since featuresets
+    are encoded as dictionaries, which can take up a lot of memory,
+    using a ``LazyMap`` can significantly reduce memory usage when
+    training and running classifiers.
+    """
+
+    def __init__(self, function, *lists, **config):
+        """
+        :param function: The function that should be applied to
+            elements of ``lists``.  It should take as many arguments
+            as there are ``lists``.
+        :param lists: The underlying lists.
+        :param cache_size: Determines the size of the cache used
+            by this lazy map.  (default=5)
+        """
+        if not lists:
+            raise TypeError("LazyMap requires at least two args")
+
+        self._lists = lists
+        self._func = function
+        self._cache_size = config.get("cache_size", 5)
+        self._cache = {} if self._cache_size > 0 else None
+
+        # If you just take bool() of sum() here _all_lazy will be true just
+        # in case n >= 1 list is an AbstractLazySequence.  Presumably this
+        # isn't what's intended.
+        self._all_lazy = sum(
+            isinstance(lst, AbstractLazySequence) for lst in lists
+        ) == len(lists)
+
+    def iterate_from(self, index):
+        # Special case: one lazy sublist
+        if len(self._lists) == 1 and self._all_lazy:
+            for value in self._lists[0].iterate_from(index):
+                yield self._func(value)
+            return
+
+        # Special case: one non-lazy sublist
+        elif len(self._lists) == 1:
+            while True:
+                try:
+                    yield self._func(self._lists[0][index])
+                except IndexError:
+                    return
+                index += 1
+
+        # Special case: n lazy sublists
+        elif self._all_lazy:
+            iterators = [lst.iterate_from(index) for lst in self._lists]
+            while True:
+                elements = []
+                for iterator in iterators:
+                    try:
+                        elements.append(next(iterator))
+                    except:  # FIXME: What is this except really catching? StopIteration?
+                        elements.append(None)
+                if elements == [None] * len(self._lists):
+                    return
+                yield self._func(*elements)
+                index += 1
+
+        # general case
+        else:
+            while True:
+                try:
+                    elements = [lst[index] for lst in self._lists]
+                except IndexError:
+                    elements = [None] * len(self._lists)
+                    for i, lst in enumerate(self._lists):
+                        try:
+                            elements[i] = lst[index]
+                        except IndexError:
+                            pass
+                    if elements == [None] * len(self._lists):
+                        return
+                yield self._func(*elements)
+                index += 1
+
+    def __getitem__(self, index):
+        if isinstance(index, slice):
+            sliced_lists = [lst[index] for lst in self._lists]
+            return LazyMap(self._func, *sliced_lists)
+        else:
+            # Handle negative indices
+            if index < 0:
+                index += len(self)
+            if index < 0:
+                raise IndexError("index out of range")
+            # Check the cache
+            if self._cache is not None and index in self._cache:
+                return self._cache[index]
+            # Calculate the value
+            try:
+                val = next(self.iterate_from(index))
+            except StopIteration as e:
+                raise IndexError("index out of range") from e
+            # Update the cache
+            if self._cache is not None:
+                if len(self._cache) > self._cache_size:
+                    self._cache.popitem()  # discard random entry
+                self._cache[index] = val
+            # Return the value
+            return val
+
+    def __len__(self):
+        return max(len(lst) for lst in self._lists)
+
+
+class LazyZip(LazyMap):
+    """
+    A lazy sequence whose elements are tuples, each containing the i-th
+    element from each of the argument sequences.  The returned list is
+    truncated in length to the length of the shortest argument sequence. The
+    tuples are constructed lazily -- i.e., when you read a value from the
+    list, ``LazyZip`` will calculate that value by forming a tuple from
+    the i-th element of each of the argument sequences.
+
+    ``LazyZip`` is essentially a lazy version of the Python primitive function
+    ``zip``.  In particular, an evaluated LazyZip is equivalent to a zip:
+
+        >>> from nltk.collections import LazyZip
+        >>> sequence1, sequence2 = [1, 2, 3], ['a', 'b', 'c']
+        >>> zip(sequence1, sequence2) # doctest: +SKIP
+        [(1, 'a'), (2, 'b'), (3, 'c')]
+        >>> list(LazyZip(sequence1, sequence2))
+        [(1, 'a'), (2, 'b'), (3, 'c')]
+        >>> sequences = [sequence1, sequence2, [6,7,8,9]]
+        >>> list(zip(*sequences)) == list(LazyZip(*sequences))
+        True
+
+    Lazy zips can be useful for conserving memory in cases where the argument
+    sequences are particularly long.
+
+    A typical example of a use case for this class is combining long sequences
+    of gold standard and predicted values in a classification or tagging task
+    in order to calculate accuracy.  By constructing tuples lazily and
+    avoiding the creation of an additional long sequence, memory usage can be
+    significantly reduced.
+    """
+
+    def __init__(self, *lists):
+        """
+        :param lists: the underlying lists
+        :type lists: list(list)
+        """
+        LazyMap.__init__(self, lambda *elts: elts, *lists)
+
+    def iterate_from(self, index):
+        iterator = LazyMap.iterate_from(self, index)
+        while index < len(self):
+            yield next(iterator)
+            index += 1
+        return
+
+    def __len__(self):
+        return min(len(lst) for lst in self._lists)
+
+
+class LazyEnumerate(LazyZip):
+    """
+    A lazy sequence whose elements are tuples, each containing a count (from
+    zero) and a value yielded by underlying sequence.  ``LazyEnumerate`` is
+    useful for obtaining an indexed list. The tuples are constructed lazily
+    -- i.e., when you read a value from the list, ``LazyEnumerate`` will
+    calculate that value by forming a tuple from the count of the i-th
+    element and the i-th element of the underlying sequence.
+
+    ``LazyEnumerate`` is essentially a lazy version of the Python primitive
+    function ``enumerate``.  In particular, the following two expressions are
+    equivalent:
+
+        >>> from nltk.collections import LazyEnumerate
+        >>> sequence = ['first', 'second', 'third']
+        >>> list(enumerate(sequence))
+        [(0, 'first'), (1, 'second'), (2, 'third')]
+        >>> list(LazyEnumerate(sequence))
+        [(0, 'first'), (1, 'second'), (2, 'third')]
+
+    Lazy enumerations can be useful for conserving memory in cases where the
+    argument sequences are particularly long.
+
+    A typical example of a use case for this class is obtaining an indexed
+    list for a long sequence of values.  By constructing tuples lazily and
+    avoiding the creation of an additional long sequence, memory usage can be
+    significantly reduced.
+    """
+
+    def __init__(self, lst):
+        """
+        :param lst: the underlying list
+        :type lst: list
+        """
+        LazyZip.__init__(self, range(len(lst)), lst)
+
+
+class LazyIteratorList(AbstractLazySequence):
+    """
+    Wraps an iterator, loading its elements on demand
+    and making them subscriptable.
+    __repr__ displays only the first few elements.
+    """
+
+    def __init__(self, it, known_len=None):
+        self._it = it
+        self._len = known_len
+        self._cache = []
+
+    def __len__(self):
+        if self._len:
+            return self._len
+        for _ in self.iterate_from(len(self._cache)):
+            pass
+        self._len = len(self._cache)
+        return self._len
+
+    def iterate_from(self, start):
+        """Create a new iterator over this list starting at the given offset."""
+        while len(self._cache) < start:
+            v = next(self._it)
+            self._cache.append(v)
+        i = start
+        while i < len(self._cache):
+            yield self._cache[i]
+            i += 1
+        try:
+            while True:
+                v = next(self._it)
+                self._cache.append(v)
+                yield v
+        except StopIteration:
+            pass
+
+    def __add__(self, other):
+        """Return a list concatenating self with other."""
+        return type(self)(chain(self, other))
+
+    def __radd__(self, other):
+        """Return a list concatenating other with self."""
+        return type(self)(chain(other, self))
+
+
+######################################################################
+# Trie Implementation
+######################################################################
+class Trie(dict):
+    """A Trie implementation for strings"""
+
+    LEAF = True
+
+    def __init__(self, strings=None):
+        """Builds a Trie object, which is built around a ``dict``
+
+        If ``strings`` is provided, it will add the ``strings``, which
+        consist of a ``list`` of ``strings``, to the Trie.
+        Otherwise, it'll construct an empty Trie.
+
+        :param strings: List of strings to insert into the trie
+            (Default is ``None``)
+        :type strings: list(str)
+
+        """
+        super().__init__()
+        if strings:
+            for string in strings:
+                self.insert(string)
+
+    def insert(self, string):
+        """Inserts ``string`` into the Trie
+
+        :param string: String to insert into the trie
+        :type string: str
+
+        :Example:
+
+        >>> from nltk.collections import Trie
+        >>> trie = Trie(["abc", "def"])
+        >>> expected = {'a': {'b': {'c': {True: None}}}, \
+                        'd': {'e': {'f': {True: None}}}}
+        >>> trie == expected
+        True
+
+        """
+        if len(string):
+            self[string[0]].insert(string[1:])
+        else:
+            # mark the string is complete
+            self[Trie.LEAF] = None
+
+    def __missing__(self, key):
+        self[key] = Trie()
+        return self[key]

llmeval-env/lib/python3.10/site-packages/nltk/collocations.py

@@ -0,0 +1,412 @@
+# Natural Language Toolkit: Collocations and Association Measures
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Joel Nothman <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+"""
+Tools to identify collocations --- words that often appear consecutively
+--- within corpora. They may also be used to find other associations between
+word occurrences.
+See Manning and Schutze ch. 5 at https://nlp.stanford.edu/fsnlp/promo/colloc.pdf
+and the Text::NSP Perl package at http://ngram.sourceforge.net
+
+Finding collocations requires first calculating the frequencies of words and
+their appearance in the context of other words. Often the collection of words
+will then requiring filtering to only retain useful content terms. Each ngram
+of words may then be scored according to some association measure, in order
+to determine the relative likelihood of each ngram being a collocation.
+
+The ``BigramCollocationFinder`` and ``TrigramCollocationFinder`` classes provide
+these functionalities, dependent on being provided a function which scores a
+ngram given appropriate frequency counts. A number of standard association
+measures are provided in bigram_measures and trigram_measures.
+"""
+
+# Possible TODOs:
+# - consider the distinction between f(x,_) and f(x) and whether our
+#   approximation is good enough for fragmented data, and mention it
+# - add a n-gram collocation finder with measures which only utilise n-gram
+#   and unigram counts (raw_freq, pmi, student_t)
+
+import itertools as _itertools
+
+# these two unused imports are referenced in collocations.doctest
+from nltk.metrics import (
+    BigramAssocMeasures,
+    ContingencyMeasures,
+    QuadgramAssocMeasures,
+    TrigramAssocMeasures,
+)
+from nltk.metrics.spearman import ranks_from_scores, spearman_correlation
+from nltk.probability import FreqDist
+from nltk.util import ngrams
+
+
+class AbstractCollocationFinder:
+    """
+    An abstract base class for collocation finders whose purpose is to
+    collect collocation candidate frequencies, filter and rank them.
+
+    As a minimum, collocation finders require the frequencies of each
+    word in a corpus, and the joint frequency of word tuples. This data
+    should be provided through nltk.probability.FreqDist objects or an
+    identical interface.
+    """
+
+    def __init__(self, word_fd, ngram_fd):
+        self.word_fd = word_fd
+        self.N = word_fd.N()
+        self.ngram_fd = ngram_fd
+
+    @classmethod
+    def _build_new_documents(
+        cls, documents, window_size, pad_left=False, pad_right=False, pad_symbol=None
+    ):
+        """
+        Pad the document with the place holder according to the window_size
+        """
+        padding = (pad_symbol,) * (window_size - 1)
+        if pad_right:
+            return _itertools.chain.from_iterable(
+                _itertools.chain(doc, padding) for doc in documents
+            )
+        if pad_left:
+            return _itertools.chain.from_iterable(
+                _itertools.chain(padding, doc) for doc in documents
+            )
+
+    @classmethod
+    def from_documents(cls, documents):
+        """Constructs a collocation finder given a collection of documents,
+        each of which is a list (or iterable) of tokens.
+        """
+        # return cls.from_words(_itertools.chain(*documents))
+        return cls.from_words(
+            cls._build_new_documents(documents, cls.default_ws, pad_right=True)
+        )
+
+    @staticmethod
+    def _ngram_freqdist(words, n):
+        return FreqDist(tuple(words[i : i + n]) for i in range(len(words) - 1))
+
+    def _apply_filter(self, fn=lambda ngram, freq: False):
+        """Generic filter removes ngrams from the frequency distribution
+        if the function returns True when passed an ngram tuple.
+        """
+        tmp_ngram = FreqDist()
+        for ngram, freq in self.ngram_fd.items():
+            if not fn(ngram, freq):
+                tmp_ngram[ngram] = freq
+        self.ngram_fd = tmp_ngram
+
+    def apply_freq_filter(self, min_freq):
+        """Removes candidate ngrams which have frequency less than min_freq."""
+        self._apply_filter(lambda ng, freq: freq < min_freq)
+
+    def apply_ngram_filter(self, fn):
+        """Removes candidate ngrams (w1, w2, ...) where fn(w1, w2, ...)
+        evaluates to True.
+        """
+        self._apply_filter(lambda ng, f: fn(*ng))
+
+    def apply_word_filter(self, fn):
+        """Removes candidate ngrams (w1, w2, ...) where any of (fn(w1), fn(w2),
+        ...) evaluates to True.
+        """
+        self._apply_filter(lambda ng, f: any(fn(w) for w in ng))
+
+    def _score_ngrams(self, score_fn):
+        """Generates of (ngram, score) pairs as determined by the scoring
+        function provided.
+        """
+        for tup in self.ngram_fd:
+            score = self.score_ngram(score_fn, *tup)
+            if score is not None:
+                yield tup, score
+
+    def score_ngrams(self, score_fn):
+        """Returns a sequence of (ngram, score) pairs ordered from highest to
+        lowest score, as determined by the scoring function provided.
+        """
+        return sorted(self._score_ngrams(score_fn), key=lambda t: (-t[1], t[0]))
+
+    def nbest(self, score_fn, n):
+        """Returns the top n ngrams when scored by the given function."""
+        return [p for p, s in self.score_ngrams(score_fn)[:n]]
+
+    def above_score(self, score_fn, min_score):
+        """Returns a sequence of ngrams, ordered by decreasing score, whose
+        scores each exceed the given minimum score.
+        """
+        for ngram, score in self.score_ngrams(score_fn):
+            if score > min_score:
+                yield ngram
+            else:
+                break
+
+
+class BigramCollocationFinder(AbstractCollocationFinder):
+    """A tool for the finding and ranking of bigram collocations or other
+    association measures. It is often useful to use from_words() rather than
+    constructing an instance directly.
+    """
+
+    default_ws = 2
+
+    def __init__(self, word_fd, bigram_fd, window_size=2):
+        """Construct a BigramCollocationFinder, given FreqDists for
+        appearances of words and (possibly non-contiguous) bigrams.
+        """
+        AbstractCollocationFinder.__init__(self, word_fd, bigram_fd)
+        self.window_size = window_size
+
+    @classmethod
+    def from_words(cls, words, window_size=2):
+        """Construct a BigramCollocationFinder for all bigrams in the given
+        sequence.  When window_size > 2, count non-contiguous bigrams, in the
+        style of Church and Hanks's (1990) association ratio.
+        """
+        wfd = FreqDist()
+        bfd = FreqDist()
+
+        if window_size < 2:
+            raise ValueError("Specify window_size at least 2")
+
+        for window in ngrams(words, window_size, pad_right=True):
+            w1 = window[0]
+            if w1 is None:
+                continue
+            wfd[w1] += 1
+            for w2 in window[1:]:
+                if w2 is not None:
+                    bfd[(w1, w2)] += 1
+        return cls(wfd, bfd, window_size=window_size)
+
+    def score_ngram(self, score_fn, w1, w2):
+        """Returns the score for a given bigram using the given scoring
+        function.  Following Church and Hanks (1990), counts are scaled by
+        a factor of 1/(window_size - 1).
+        """
+        n_all = self.N
+        n_ii = self.ngram_fd[(w1, w2)] / (self.window_size - 1.0)
+        if not n_ii:
+            return
+        n_ix = self.word_fd[w1]
+        n_xi = self.word_fd[w2]
+        return score_fn(n_ii, (n_ix, n_xi), n_all)
+
+
+class TrigramCollocationFinder(AbstractCollocationFinder):
+    """A tool for the finding and ranking of trigram collocations or other
+    association measures. It is often useful to use from_words() rather than
+    constructing an instance directly.
+    """
+
+    default_ws = 3
+
+    def __init__(self, word_fd, bigram_fd, wildcard_fd, trigram_fd):
+        """Construct a TrigramCollocationFinder, given FreqDists for
+        appearances of words, bigrams, two words with any word between them,
+        and trigrams.
+        """
+        AbstractCollocationFinder.__init__(self, word_fd, trigram_fd)
+        self.wildcard_fd = wildcard_fd
+        self.bigram_fd = bigram_fd
+
+    @classmethod
+    def from_words(cls, words, window_size=3):
+        """Construct a TrigramCollocationFinder for all trigrams in the given
+        sequence.
+        """
+        if window_size < 3:
+            raise ValueError("Specify window_size at least 3")
+
+        wfd = FreqDist()
+        wildfd = FreqDist()
+        bfd = FreqDist()
+        tfd = FreqDist()
+        for window in ngrams(words, window_size, pad_right=True):
+            w1 = window[0]
+            if w1 is None:
+                continue
+            for w2, w3 in _itertools.combinations(window[1:], 2):
+                wfd[w1] += 1
+                if w2 is None:
+                    continue
+                bfd[(w1, w2)] += 1
+                if w3 is None:
+                    continue
+                wildfd[(w1, w3)] += 1
+                tfd[(w1, w2, w3)] += 1
+        return cls(wfd, bfd, wildfd, tfd)
+
+    def bigram_finder(self):
+        """Constructs a bigram collocation finder with the bigram and unigram
+        data from this finder. Note that this does not include any filtering
+        applied to this finder.
+        """
+        return BigramCollocationFinder(self.word_fd, self.bigram_fd)
+
+    def score_ngram(self, score_fn, w1, w2, w3):
+        """Returns the score for a given trigram using the given scoring
+        function.
+        """
+        n_all = self.N
+        n_iii = self.ngram_fd[(w1, w2, w3)]
+        if not n_iii:
+            return
+        n_iix = self.bigram_fd[(w1, w2)]
+        n_ixi = self.wildcard_fd[(w1, w3)]
+        n_xii = self.bigram_fd[(w2, w3)]
+        n_ixx = self.word_fd[w1]
+        n_xix = self.word_fd[w2]
+        n_xxi = self.word_fd[w3]
+        return score_fn(n_iii, (n_iix, n_ixi, n_xii), (n_ixx, n_xix, n_xxi), n_all)
+
+
+class QuadgramCollocationFinder(AbstractCollocationFinder):
+    """A tool for the finding and ranking of quadgram collocations or other association measures.
+    It is often useful to use from_words() rather than constructing an instance directly.
+    """
+
+    default_ws = 4
+
+    def __init__(self, word_fd, quadgram_fd, ii, iii, ixi, ixxi, iixi, ixii):
+        """Construct a QuadgramCollocationFinder, given FreqDists for appearances of words,
+        bigrams, trigrams, two words with one word and two words between them, three words
+        with a word between them in both variations.
+        """
+        AbstractCollocationFinder.__init__(self, word_fd, quadgram_fd)
+        self.iii = iii
+        self.ii = ii
+        self.ixi = ixi
+        self.ixxi = ixxi
+        self.iixi = iixi
+        self.ixii = ixii
+
+    @classmethod
+    def from_words(cls, words, window_size=4):
+        if window_size < 4:
+            raise ValueError("Specify window_size at least 4")
+        ixxx = FreqDist()
+        iiii = FreqDist()
+        ii = FreqDist()
+        iii = FreqDist()
+        ixi = FreqDist()
+        ixxi = FreqDist()
+        iixi = FreqDist()
+        ixii = FreqDist()
+
+        for window in ngrams(words, window_size, pad_right=True):
+            w1 = window[0]
+            if w1 is None:
+                continue
+            for w2, w3, w4 in _itertools.combinations(window[1:], 3):
+                ixxx[w1] += 1
+                if w2 is None:
+                    continue
+                ii[(w1, w2)] += 1
+                if w3 is None:
+                    continue
+                iii[(w1, w2, w3)] += 1
+                ixi[(w1, w3)] += 1
+                if w4 is None:
+                    continue
+                iiii[(w1, w2, w3, w4)] += 1
+                ixxi[(w1, w4)] += 1
+                ixii[(w1, w3, w4)] += 1
+                iixi[(w1, w2, w4)] += 1
+
+        return cls(ixxx, iiii, ii, iii, ixi, ixxi, iixi, ixii)
+
+    def score_ngram(self, score_fn, w1, w2, w3, w4):
+        n_all = self.N
+        n_iiii = self.ngram_fd[(w1, w2, w3, w4)]
+        if not n_iiii:
+            return
+        n_iiix = self.iii[(w1, w2, w3)]
+        n_xiii = self.iii[(w2, w3, w4)]
+        n_iixi = self.iixi[(w1, w2, w4)]
+        n_ixii = self.ixii[(w1, w3, w4)]
+
+        n_iixx = self.ii[(w1, w2)]
+        n_xxii = self.ii[(w3, w4)]
+        n_xiix = self.ii[(w2, w3)]
+        n_ixix = self.ixi[(w1, w3)]
+        n_ixxi = self.ixxi[(w1, w4)]
+        n_xixi = self.ixi[(w2, w4)]
+
+        n_ixxx = self.word_fd[w1]
+        n_xixx = self.word_fd[w2]
+        n_xxix = self.word_fd[w3]
+        n_xxxi = self.word_fd[w4]
+        return score_fn(
+            n_iiii,
+            (n_iiix, n_iixi, n_ixii, n_xiii),
+            (n_iixx, n_ixix, n_ixxi, n_xixi, n_xxii, n_xiix),
+            (n_ixxx, n_xixx, n_xxix, n_xxxi),
+            n_all,
+        )
+
+
+def demo(scorer=None, compare_scorer=None):
+    """Finds bigram collocations in the files of the WebText corpus."""
+    from nltk.metrics import (
+        BigramAssocMeasures,
+        ranks_from_scores,
+        spearman_correlation,
+    )
+
+    if scorer is None:
+        scorer = BigramAssocMeasures.likelihood_ratio
+    if compare_scorer is None:
+        compare_scorer = BigramAssocMeasures.raw_freq
+
+    from nltk.corpus import stopwords, webtext
+
+    ignored_words = stopwords.words("english")
+    word_filter = lambda w: len(w) < 3 or w.lower() in ignored_words
+
+    for file in webtext.fileids():
+        words = [word.lower() for word in webtext.words(file)]
+
+        cf = BigramCollocationFinder.from_words(words)
+        cf.apply_freq_filter(3)
+        cf.apply_word_filter(word_filter)
+
+        corr = spearman_correlation(
+            ranks_from_scores(cf.score_ngrams(scorer)),
+            ranks_from_scores(cf.score_ngrams(compare_scorer)),
+        )
+        print(file)
+        print("\t", [" ".join(tup) for tup in cf.nbest(scorer, 15)])
+        print(f"\t Correlation to {compare_scorer.__name__}: {corr:0.4f}")
+
+
+# Slows down loading too much
+# bigram_measures = BigramAssocMeasures()
+# trigram_measures = TrigramAssocMeasures()
+
+if __name__ == "__main__":
+    import sys
+
+    from nltk.metrics import BigramAssocMeasures
+
+    try:
+        scorer = eval("BigramAssocMeasures." + sys.argv[1])
+    except IndexError:
+        scorer = None
+    try:
+        compare_scorer = eval("BigramAssocMeasures." + sys.argv[2])
+    except IndexError:
+        compare_scorer = None
+
+    demo(scorer, compare_scorer)
+
+__all__ = [
+    "BigramCollocationFinder",
+    "TrigramCollocationFinder",
+    "QuadgramCollocationFinder",
+]

llmeval-env/lib/python3.10/site-packages/nltk/compat.py

@@ -0,0 +1,43 @@
+# Natural Language Toolkit: Compatibility
+#
+# Copyright (C) 2001-2023 NLTK Project
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import os
+from functools import wraps
+
+# ======= Compatibility for datasets that care about Python versions ========
+
+# The following datasets have a /PY3 subdirectory containing
+# a full copy of the data which has been re-encoded or repickled.
+DATA_UPDATES = [
+    ("chunkers", "maxent_ne_chunker"),
+    ("help", "tagsets"),
+    ("taggers", "maxent_treebank_pos_tagger"),
+    ("tokenizers", "punkt"),
+]
+
+_PY3_DATA_UPDATES = [os.path.join(*path_list) for path_list in DATA_UPDATES]
+
+
+def add_py3_data(path):
+    for item in _PY3_DATA_UPDATES:
+        if item in str(path) and "/PY3" not in str(path):
+            pos = path.index(item) + len(item)
+            if path[pos : pos + 4] == ".zip":
+                pos += 4
+            path = path[:pos] + "/PY3" + path[pos:]
+            break
+    return path
+
+
+# for use in adding /PY3 to the second (filename) argument
+# of the file pointers in data.py
+def py3_data(init_func):
+    def _decorator(*args, **kwargs):
+        args = (args[0], add_py3_data(args[1])) + args[2:]
+        return init_func(*args, **kwargs)
+
+    return wraps(init_func)(_decorator)

llmeval-env/lib/python3.10/site-packages/nltk/data.py

@@ -0,0 +1,1441 @@
+# Natural Language Toolkit: Utility functions
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Functions to find and load NLTK resource files, such as corpora,
+grammars, and saved processing objects.  Resource files are identified
+using URLs, such as ``nltk:corpora/abc/rural.txt`` or
+``https://raw.githubusercontent.com/nltk/nltk/develop/nltk/test/toy.cfg``.
+The following URL protocols are supported:
+
+  - ``file:path``: Specifies the file whose path is *path*.
+    Both relative and absolute paths may be used.
+
+  - ``https://host/path``: Specifies the file stored on the web
+    server *host* at path *path*.
+
+  - ``nltk:path``: Specifies the file stored in the NLTK data
+    package at *path*.  NLTK will search for these files in the
+    directories specified by ``nltk.data.path``.
+
+If no protocol is specified, then the default protocol ``nltk:`` will
+be used.
+
+This module provides to functions that can be used to access a
+resource file, given its URL: ``load()`` loads a given resource, and
+adds it to a resource cache; and ``retrieve()`` copies a given resource
+to a local file.
+"""
+
+import codecs
+import functools
+import os
+import pickle
+import re
+import sys
+import textwrap
+import zipfile
+from abc import ABCMeta, abstractmethod
+from gzip import WRITE as GZ_WRITE
+from gzip import GzipFile
+from io import BytesIO, TextIOWrapper
+from urllib.request import url2pathname, urlopen
+
+try:
+    from zlib import Z_SYNC_FLUSH as FLUSH
+except ImportError:
+    from zlib import Z_FINISH as FLUSH
+
+from nltk import grammar, sem
+from nltk.compat import add_py3_data, py3_data
+from nltk.internals import deprecated
+
+textwrap_indent = functools.partial(textwrap.indent, prefix="  ")
+
+######################################################################
+# Search Path
+######################################################################
+
+path = []
+"""A list of directories where the NLTK data package might reside.
+   These directories will be checked in order when looking for a
+   resource in the data package.  Note that this allows users to
+   substitute in their own versions of resources, if they have them
+   (e.g., in their home directory under ~/nltk_data)."""
+
+# User-specified locations:
+_paths_from_env = os.environ.get("NLTK_DATA", "").split(os.pathsep)
+path += [d for d in _paths_from_env if d]
+if "APPENGINE_RUNTIME" not in os.environ and os.path.expanduser("~/") != "~/":
+    path.append(os.path.expanduser("~/nltk_data"))
+
+if sys.platform.startswith("win"):
+    # Common locations on Windows:
+    path += [
+        os.path.join(sys.prefix, "nltk_data"),
+        os.path.join(sys.prefix, "share", "nltk_data"),
+        os.path.join(sys.prefix, "lib", "nltk_data"),
+        os.path.join(os.environ.get("APPDATA", "C:\\"), "nltk_data"),
+        r"C:\nltk_data",
+        r"D:\nltk_data",
+        r"E:\nltk_data",
+    ]
+else:
+    # Common locations on UNIX & OS X:
+    path += [
+        os.path.join(sys.prefix, "nltk_data"),
+        os.path.join(sys.prefix, "share", "nltk_data"),
+        os.path.join(sys.prefix, "lib", "nltk_data"),
+        "/usr/share/nltk_data",
+        "/usr/local/share/nltk_data",
+        "/usr/lib/nltk_data",
+        "/usr/local/lib/nltk_data",
+    ]
+
+
+######################################################################
+# Util Functions
+######################################################################
+
+
+def gzip_open_unicode(
+    filename,
+    mode="rb",
+    compresslevel=9,
+    encoding="utf-8",
+    fileobj=None,
+    errors=None,
+    newline=None,
+):
+    if fileobj is None:
+        fileobj = GzipFile(filename, mode, compresslevel, fileobj)
+    return TextIOWrapper(fileobj, encoding, errors, newline)
+
+
+def split_resource_url(resource_url):
+    """
+    Splits a resource url into "<protocol>:<path>".
+
+    >>> windows = sys.platform.startswith('win')
+    >>> split_resource_url('nltk:home/nltk')
+    ('nltk', 'home/nltk')
+    >>> split_resource_url('nltk:/home/nltk')
+    ('nltk', '/home/nltk')
+    >>> split_resource_url('file:/home/nltk')
+    ('file', '/home/nltk')
+    >>> split_resource_url('file:///home/nltk')
+    ('file', '/home/nltk')
+    >>> split_resource_url('file:///C:/home/nltk')
+    ('file', '/C:/home/nltk')
+    """
+    protocol, path_ = resource_url.split(":", 1)
+    if protocol == "nltk":
+        pass
+    elif protocol == "file":
+        if path_.startswith("/"):
+            path_ = "/" + path_.lstrip("/")
+    else:
+        path_ = re.sub(r"^/{0,2}", "", path_)
+    return protocol, path_
+
+
+def normalize_resource_url(resource_url):
+    r"""
+    Normalizes a resource url
+
+    >>> windows = sys.platform.startswith('win')
+    >>> os.path.normpath(split_resource_url(normalize_resource_url('file:grammar.fcfg'))[1]) == \
+    ... ('\\' if windows else '') + os.path.abspath(os.path.join(os.curdir, 'grammar.fcfg'))
+    True
+    >>> not windows or normalize_resource_url('file:C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file:C:\\dir\\file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file:C:\\dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file://C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('file:////C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('nltk:C:/dir/file') == 'file:///C:/dir/file'
+    True
+    >>> not windows or normalize_resource_url('nltk:C:\\dir\\file') == 'file:///C:/dir/file'
+    True
+    >>> windows or normalize_resource_url('file:/dir/file/toy.cfg') == 'file:///dir/file/toy.cfg'
+    True
+    >>> normalize_resource_url('nltk:home/nltk')
+    'nltk:home/nltk'
+    >>> windows or normalize_resource_url('nltk:/home/nltk') == 'file:///home/nltk'
+    True
+    >>> normalize_resource_url('https://example.com/dir/file')
+    'https://example.com/dir/file'
+    >>> normalize_resource_url('dir/file')
+    'nltk:dir/file'
+    """
+    try:
+        protocol, name = split_resource_url(resource_url)
+    except ValueError:
+        # the resource url has no protocol, use the nltk protocol by default
+        protocol = "nltk"
+        name = resource_url
+    # use file protocol if the path is an absolute path
+    if protocol == "nltk" and os.path.isabs(name):
+        protocol = "file://"
+        name = normalize_resource_name(name, False, None)
+    elif protocol == "file":
+        protocol = "file://"
+        # name is absolute
+        name = normalize_resource_name(name, False, None)
+    elif protocol == "nltk":
+        protocol = "nltk:"
+        name = normalize_resource_name(name, True)
+    else:
+        # handled by urllib
+        protocol += "://"
+    return "".join([protocol, name])
+
+
+def normalize_resource_name(resource_name, allow_relative=True, relative_path=None):
+    """
+    :type resource_name: str or unicode
+    :param resource_name: The name of the resource to search for.
+        Resource names are posix-style relative path names, such as
+        ``corpora/brown``.  Directory names will automatically
+        be converted to a platform-appropriate path separator.
+        Directory trailing slashes are preserved
+
+    >>> windows = sys.platform.startswith('win')
+    >>> normalize_resource_name('.', True)
+    './'
+    >>> normalize_resource_name('./', True)
+    './'
+    >>> windows or normalize_resource_name('dir/file', False, '/') == '/dir/file'
+    True
+    >>> not windows or normalize_resource_name('C:/file', False, '/') == '/C:/file'
+    True
+    >>> windows or normalize_resource_name('/dir/file', False, '/') == '/dir/file'
+    True
+    >>> windows or normalize_resource_name('../dir/file', False, '/') == '/dir/file'
+    True
+    >>> not windows or normalize_resource_name('/dir/file', True, '/') == 'dir/file'
+    True
+    >>> windows or normalize_resource_name('/dir/file', True, '/') == '/dir/file'
+    True
+    """
+    is_dir = bool(re.search(r"[\\/.]$", resource_name)) or resource_name.endswith(
+        os.path.sep
+    )
+    if sys.platform.startswith("win"):
+        resource_name = resource_name.lstrip("/")
+    else:
+        resource_name = re.sub(r"^/+", "/", resource_name)
+    if allow_relative:
+        resource_name = os.path.normpath(resource_name)
+    else:
+        if relative_path is None:
+            relative_path = os.curdir
+        resource_name = os.path.abspath(os.path.join(relative_path, resource_name))
+    resource_name = resource_name.replace("\\", "/").replace(os.path.sep, "/")
+    if sys.platform.startswith("win") and os.path.isabs(resource_name):
+        resource_name = "/" + resource_name
+    if is_dir and not resource_name.endswith("/"):
+        resource_name += "/"
+    return resource_name
+
+
+######################################################################
+# Path Pointers
+######################################################################
+
+
+class PathPointer(metaclass=ABCMeta):
+    """
+    An abstract base class for 'path pointers,' used by NLTK's data
+    package to identify specific paths.  Two subclasses exist:
+    ``FileSystemPathPointer`` identifies a file that can be accessed
+    directly via a given absolute path.  ``ZipFilePathPointer``
+    identifies a file contained within a zipfile, that can be accessed
+    by reading that zipfile.
+    """
+
+    @abstractmethod
+    def open(self, encoding=None):
+        """
+        Return a seekable read-only stream that can be used to read
+        the contents of the file identified by this path pointer.
+
+        :raise IOError: If the path specified by this pointer does
+            not contain a readable file.
+        """
+
+    @abstractmethod
+    def file_size(self):
+        """
+        Return the size of the file pointed to by this path pointer,
+        in bytes.
+
+        :raise IOError: If the path specified by this pointer does
+            not contain a readable file.
+        """
+
+    @abstractmethod
+    def join(self, fileid):
+        """
+        Return a new path pointer formed by starting at the path
+        identified by this pointer, and then following the relative
+        path given by ``fileid``.  The path components of ``fileid``
+        should be separated by forward slashes, regardless of
+        the underlying file system's path separator character.
+        """
+
+
+class FileSystemPathPointer(PathPointer, str):
+    """
+    A path pointer that identifies a file which can be accessed
+    directly via a given absolute path.
+    """
+
+    @py3_data
+    def __init__(self, _path):
+        """
+        Create a new path pointer for the given absolute path.
+
+        :raise IOError: If the given path does not exist.
+        """
+
+        _path = os.path.abspath(_path)
+        if not os.path.exists(_path):
+            raise OSError("No such file or directory: %r" % _path)
+        self._path = _path
+
+        # There's no need to call str.__init__(), since it's a no-op;
+        # str does all of its setup work in __new__.
+
+    @property
+    def path(self):
+        """The absolute path identified by this path pointer."""
+        return self._path
+
+    def open(self, encoding=None):
+        stream = open(self._path, "rb")
+        if encoding is not None:
+            stream = SeekableUnicodeStreamReader(stream, encoding)
+        return stream
+
+    def file_size(self):
+        return os.stat(self._path).st_size
+
+    def join(self, fileid):
+        _path = os.path.join(self._path, fileid)
+        return FileSystemPathPointer(_path)
+
+    def __repr__(self):
+        return "FileSystemPathPointer(%r)" % self._path
+
+    def __str__(self):
+        return self._path
+
+
+@deprecated("Use gzip.GzipFile instead as it also uses a buffer.")
+class BufferedGzipFile(GzipFile):
+    """A ``GzipFile`` subclass for compatibility with older nltk releases.
+
+    Use ``GzipFile`` directly as it also buffers in all supported
+    Python versions.
+    """
+
+    @py3_data
+    def __init__(
+        self, filename=None, mode=None, compresslevel=9, fileobj=None, **kwargs
+    ):
+        """Return a buffered gzip file object."""
+        GzipFile.__init__(self, filename, mode, compresslevel, fileobj)
+
+    def write(self, data):
+        # This is identical to GzipFile.write but does not return
+        # the bytes written to retain compatibility.
+        super().write(data)
+
+
+class GzipFileSystemPathPointer(FileSystemPathPointer):
+    """
+    A subclass of ``FileSystemPathPointer`` that identifies a gzip-compressed
+    file located at a given absolute path.  ``GzipFileSystemPathPointer`` is
+    appropriate for loading large gzip-compressed pickle objects efficiently.
+    """
+
+    def open(self, encoding=None):
+        stream = GzipFile(self._path, "rb")
+        if encoding:
+            stream = SeekableUnicodeStreamReader(stream, encoding)
+        return stream
+
+
+class ZipFilePathPointer(PathPointer):
+    """
+    A path pointer that identifies a file contained within a zipfile,
+    which can be accessed by reading that zipfile.
+    """
+
+    @py3_data
+    def __init__(self, zipfile, entry=""):
+        """
+        Create a new path pointer pointing at the specified entry
+        in the given zipfile.
+
+        :raise IOError: If the given zipfile does not exist, or if it
+        does not contain the specified entry.
+        """
+        if isinstance(zipfile, str):
+            zipfile = OpenOnDemandZipFile(os.path.abspath(zipfile))
+
+        # Check that the entry exists:
+        if entry:
+
+            # Normalize the entry string, it should be relative:
+            entry = normalize_resource_name(entry, True, "/").lstrip("/")
+
+            try:
+                zipfile.getinfo(entry)
+            except Exception as e:
+                # Sometimes directories aren't explicitly listed in
+                # the zip file.  So if `entry` is a directory name,
+                # then check if the zipfile contains any files that
+                # are under the given directory.
+                if entry.endswith("/") and [
+                    n for n in zipfile.namelist() if n.startswith(entry)
+                ]:
+                    pass  # zipfile contains a file in that directory.
+                else:
+                    # Otherwise, complain.
+                    raise OSError(
+                        f"Zipfile {zipfile.filename!r} does not contain {entry!r}"
+                    ) from e
+        self._zipfile = zipfile
+        self._entry = entry
+
+    @property
+    def zipfile(self):
+        """
+        The zipfile.ZipFile object used to access the zip file
+        containing the entry identified by this path pointer.
+        """
+        return self._zipfile
+
+    @property
+    def entry(self):
+        """
+        The name of the file within zipfile that this path
+        pointer points to.
+        """
+        return self._entry
+
+    def open(self, encoding=None):
+        data = self._zipfile.read(self._entry)
+        stream = BytesIO(data)
+        if self._entry.endswith(".gz"):
+            stream = GzipFile(self._entry, fileobj=stream)
+        elif encoding is not None:
+            stream = SeekableUnicodeStreamReader(stream, encoding)
+        return stream
+
+    def file_size(self):
+        return self._zipfile.getinfo(self._entry).file_size
+
+    def join(self, fileid):
+        entry = f"{self._entry}/{fileid}"
+        return ZipFilePathPointer(self._zipfile, entry)
+
+    def __repr__(self):
+        return f"ZipFilePathPointer({self._zipfile.filename!r}, {self._entry!r})"
+
+    def __str__(self):
+        return os.path.normpath(os.path.join(self._zipfile.filename, self._entry))
+
+
+######################################################################
+# Access Functions
+######################################################################
+
+# Don't use a weak dictionary, because in the common case this
+# causes a lot more reloading that necessary.
+_resource_cache = {}
+"""A dictionary used to cache resources so that they won't
+   need to be loaded more than once."""
+
+
+def find(resource_name, paths=None):
+    """
+    Find the given resource by searching through the directories and
+    zip files in paths, where a None or empty string specifies an absolute path.
+    Returns a corresponding path name.  If the given resource is not
+    found, raise a ``LookupError``, whose message gives a pointer to
+    the installation instructions for the NLTK downloader.
+
+    Zip File Handling:
+
+      - If ``resource_name`` contains a component with a ``.zip``
+        extension, then it is assumed to be a zipfile; and the
+        remaining path components are used to look inside the zipfile.
+
+      - If any element of ``nltk.data.path`` has a ``.zip`` extension,
+        then it is assumed to be a zipfile.
+
+      - If a given resource name that does not contain any zipfile
+        component is not found initially, then ``find()`` will make a
+        second attempt to find that resource, by replacing each
+        component *p* in the path with *p.zip/p*.  For example, this
+        allows ``find()`` to map the resource name
+        ``corpora/chat80/cities.pl`` to a zip file path pointer to
+        ``corpora/chat80.zip/chat80/cities.pl``.
+
+      - When using ``find()`` to locate a directory contained in a
+        zipfile, the resource name must end with the forward slash
+        character.  Otherwise, ``find()`` will not locate the
+        directory.
+
+    :type resource_name: str or unicode
+    :param resource_name: The name of the resource to search for.
+        Resource names are posix-style relative path names, such as
+        ``corpora/brown``.  Directory names will be
+        automatically converted to a platform-appropriate path separator.
+    :rtype: str
+    """
+    resource_name = normalize_resource_name(resource_name, True)
+
+    # Resolve default paths at runtime in-case the user overrides
+    # nltk.data.path
+    if paths is None:
+        paths = path
+
+    # Check if the resource name includes a zipfile name
+    m = re.match(r"(.*\.zip)/?(.*)$|", resource_name)
+    zipfile, zipentry = m.groups()
+
+    # Check each item in our path
+    for path_ in paths:
+        # Is the path item a zipfile?
+        if path_ and (os.path.isfile(path_) and path_.endswith(".zip")):
+            try:
+                return ZipFilePathPointer(path_, resource_name)
+            except OSError:
+                # resource not in zipfile
+                continue
+
+        # Is the path item a directory or is resource_name an absolute path?
+        elif not path_ or os.path.isdir(path_):
+            if zipfile is None:
+                p = os.path.join(path_, url2pathname(resource_name))
+                if os.path.exists(p):
+                    if p.endswith(".gz"):
+                        return GzipFileSystemPathPointer(p)
+                    else:
+                        return FileSystemPathPointer(p)
+            else:
+                p = os.path.join(path_, url2pathname(zipfile))
+                if os.path.exists(p):
+                    try:
+                        return ZipFilePathPointer(p, zipentry)
+                    except OSError:
+                        # resource not in zipfile
+                        continue
+
+    # Fallback: if the path doesn't include a zip file, then try
+    # again, assuming that one of the path components is inside a
+    # zipfile of the same name.
+    if zipfile is None:
+        pieces = resource_name.split("/")
+        for i in range(len(pieces)):
+            modified_name = "/".join(pieces[:i] + [pieces[i] + ".zip"] + pieces[i:])
+            try:
+                return find(modified_name, paths)
+            except LookupError:
+                pass
+
+    # Identify the package (i.e. the .zip file) to download.
+    resource_zipname = resource_name.split("/")[1]
+    if resource_zipname.endswith(".zip"):
+        resource_zipname = resource_zipname.rpartition(".")[0]
+    # Display a friendly error message if the resource wasn't found:
+    msg = str(
+        "Resource \33[93m{resource}\033[0m not found.\n"
+        "Please use the NLTK Downloader to obtain the resource:\n\n"
+        "\33[31m"  # To display red text in terminal.
+        ">>> import nltk\n"
+        ">>> nltk.download('{resource}')\n"
+        "\033[0m"
+    ).format(resource=resource_zipname)
+    msg = textwrap_indent(msg)
+
+    msg += "\n  For more information see: https://www.nltk.org/data.html\n"
+
+    msg += "\n  Attempted to load \33[93m{resource_name}\033[0m\n".format(
+        resource_name=resource_name
+    )
+
+    msg += "\n  Searched in:" + "".join("\n    - %r" % d for d in paths)
+    sep = "*" * 70
+    resource_not_found = f"\n{sep}\n{msg}\n{sep}\n"
+    raise LookupError(resource_not_found)
+
+
+def retrieve(resource_url, filename=None, verbose=True):
+    """
+    Copy the given resource to a local file.  If no filename is
+    specified, then use the URL's filename.  If there is already a
+    file named ``filename``, then raise a ``ValueError``.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    """
+    resource_url = normalize_resource_url(resource_url)
+    if filename is None:
+        if resource_url.startswith("file:"):
+            filename = os.path.split(resource_url)[-1]
+        else:
+            filename = re.sub(r"(^\w+:)?.*/", "", resource_url)
+    if os.path.exists(filename):
+        filename = os.path.abspath(filename)
+        raise ValueError("File %r already exists!" % filename)
+
+    if verbose:
+        print(f"Retrieving {resource_url!r}, saving to {filename!r}")
+
+    # Open the input & output streams.
+    infile = _open(resource_url)
+
+    # Copy infile -> outfile, using 64k blocks.
+    with open(filename, "wb") as outfile:
+        while True:
+            s = infile.read(1024 * 64)  # 64k blocks.
+            outfile.write(s)
+            if not s:
+                break
+
+    infile.close()
+
+
+#: A dictionary describing the formats that are supported by NLTK's
+#: load() method.  Keys are format names, and values are format
+#: descriptions.
+FORMATS = {
+    "pickle": "A serialized python object, stored using the pickle module.",
+    "json": "A serialized python object, stored using the json module.",
+    "yaml": "A serialized python object, stored using the yaml module.",
+    "cfg": "A context free grammar.",
+    "pcfg": "A probabilistic CFG.",
+    "fcfg": "A feature CFG.",
+    "fol": "A list of first order logic expressions, parsed with "
+    "nltk.sem.logic.Expression.fromstring.",
+    "logic": "A list of first order logic expressions, parsed with "
+    "nltk.sem.logic.LogicParser.  Requires an additional logic_parser "
+    "parameter",
+    "val": "A semantic valuation, parsed by nltk.sem.Valuation.fromstring.",
+    "raw": "The raw (byte string) contents of a file.",
+    "text": "The raw (unicode string) contents of a file. ",
+}
+
+#: A dictionary mapping from file extensions to format names, used
+#: by load() when format="auto" to decide the format for a
+#: given resource url.
+AUTO_FORMATS = {
+    "pickle": "pickle",
+    "json": "json",
+    "yaml": "yaml",
+    "cfg": "cfg",
+    "pcfg": "pcfg",
+    "fcfg": "fcfg",
+    "fol": "fol",
+    "logic": "logic",
+    "val": "val",
+    "txt": "text",
+    "text": "text",
+}
+
+
+def load(
+    resource_url,
+    format="auto",
+    cache=True,
+    verbose=False,
+    logic_parser=None,
+    fstruct_reader=None,
+    encoding=None,
+):
+    """
+    Load a given resource from the NLTK data package.  The following
+    resource formats are currently supported:
+
+      - ``pickle``
+      - ``json``
+      - ``yaml``
+      - ``cfg`` (context free grammars)
+      - ``pcfg`` (probabilistic CFGs)
+      - ``fcfg`` (feature-based CFGs)
+      - ``fol`` (formulas of First Order Logic)
+      - ``logic`` (Logical formulas to be parsed by the given logic_parser)
+      - ``val`` (valuation of First Order Logic model)
+      - ``text`` (the file contents as a unicode string)
+      - ``raw`` (the raw file contents as a byte string)
+
+    If no format is specified, ``load()`` will attempt to determine a
+    format based on the resource name's file extension.  If that
+    fails, ``load()`` will raise a ``ValueError`` exception.
+
+    For all text formats (everything except ``pickle``, ``json``, ``yaml`` and ``raw``),
+    it tries to decode the raw contents using UTF-8, and if that doesn't
+    work, it tries with ISO-8859-1 (Latin-1), unless the ``encoding``
+    is specified.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    :type cache: bool
+    :param cache: If true, add this resource to a cache.  If load()
+        finds a resource in its cache, then it will return it from the
+        cache rather than loading it.
+    :type verbose: bool
+    :param verbose: If true, print a message when loading a resource.
+        Messages are not displayed when a resource is retrieved from
+        the cache.
+    :type logic_parser: LogicParser
+    :param logic_parser: The parser that will be used to parse logical
+        expressions.
+    :type fstruct_reader: FeatStructReader
+    :param fstruct_reader: The parser that will be used to parse the
+        feature structure of an fcfg.
+    :type encoding: str
+    :param encoding: the encoding of the input; only used for text formats.
+    """
+    resource_url = normalize_resource_url(resource_url)
+    resource_url = add_py3_data(resource_url)
+
+    # Determine the format of the resource.
+    if format == "auto":
+        resource_url_parts = resource_url.split(".")
+        ext = resource_url_parts[-1]
+        if ext == "gz":
+            ext = resource_url_parts[-2]
+        format = AUTO_FORMATS.get(ext)
+        if format is None:
+            raise ValueError(
+                "Could not determine format for %s based "
+                'on its file\nextension; use the "format" '
+                "argument to specify the format explicitly." % resource_url
+            )
+
+    if format not in FORMATS:
+        raise ValueError(f"Unknown format type: {format}!")
+
+    # If we've cached the resource, then just return it.
+    if cache:
+        resource_val = _resource_cache.get((resource_url, format))
+        if resource_val is not None:
+            if verbose:
+                print(f"<<Using cached copy of {resource_url}>>")
+            return resource_val
+
+    # Let the user know what's going on.
+    if verbose:
+        print(f"<<Loading {resource_url}>>")
+
+    # Load the resource.
+    opened_resource = _open(resource_url)
+
+    if format == "raw":
+        resource_val = opened_resource.read()
+    elif format == "pickle":
+        resource_val = pickle.load(opened_resource)
+    elif format == "json":
+        import json
+
+        from nltk.jsontags import json_tags
+
+        resource_val = json.load(opened_resource)
+        tag = None
+        if len(resource_val) != 1:
+            tag = next(resource_val.keys())
+        if tag not in json_tags:
+            raise ValueError("Unknown json tag.")
+    elif format == "yaml":
+        import yaml
+
+        resource_val = yaml.safe_load(opened_resource)
+    else:
+        # The resource is a text format.
+        binary_data = opened_resource.read()
+        if encoding is not None:
+            string_data = binary_data.decode(encoding)
+        else:
+            try:
+                string_data = binary_data.decode("utf-8")
+            except UnicodeDecodeError:
+                string_data = binary_data.decode("latin-1")
+        if format == "text":
+            resource_val = string_data
+        elif format == "cfg":
+            resource_val = grammar.CFG.fromstring(string_data, encoding=encoding)
+        elif format == "pcfg":
+            resource_val = grammar.PCFG.fromstring(string_data, encoding=encoding)
+        elif format == "fcfg":
+            resource_val = grammar.FeatureGrammar.fromstring(
+                string_data,
+                logic_parser=logic_parser,
+                fstruct_reader=fstruct_reader,
+                encoding=encoding,
+            )
+        elif format == "fol":
+            resource_val = sem.read_logic(
+                string_data,
+                logic_parser=sem.logic.LogicParser(),
+                encoding=encoding,
+            )
+        elif format == "logic":
+            resource_val = sem.read_logic(
+                string_data, logic_parser=logic_parser, encoding=encoding
+            )
+        elif format == "val":
+            resource_val = sem.read_valuation(string_data, encoding=encoding)
+        else:
+            raise AssertionError(
+                "Internal NLTK error: Format %s isn't "
+                "handled by nltk.data.load()" % (format,)
+            )
+
+    opened_resource.close()
+
+    # If requested, add it to the cache.
+    if cache:
+        try:
+            _resource_cache[(resource_url, format)] = resource_val
+            # TODO: add this line
+            # print('<<Caching a copy of %s>>' % (resource_url,))
+        except TypeError:
+            # We can't create weak references to some object types, like
+            # strings and tuples.  For now, just don't cache them.
+            pass
+
+    return resource_val
+
+
+def show_cfg(resource_url, escape="##"):
+    """
+    Write out a grammar file, ignoring escaped and empty lines.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    :type escape: str
+    :param escape: Prepended string that signals lines to be ignored
+    """
+    resource_url = normalize_resource_url(resource_url)
+    resource_val = load(resource_url, format="text", cache=False)
+    lines = resource_val.splitlines()
+    for l in lines:
+        if l.startswith(escape):
+            continue
+        if re.match("^$", l):
+            continue
+        print(l)
+
+
+def clear_cache():
+    """
+    Remove all objects from the resource cache.
+    :see: load()
+    """
+    _resource_cache.clear()
+
+
+def _open(resource_url):
+    """
+    Helper function that returns an open file object for a resource,
+    given its resource URL.  If the given resource URL uses the "nltk:"
+    protocol, or uses no protocol, then use ``nltk.data.find`` to find
+    its path, and open it with the given mode; if the resource URL
+    uses the 'file' protocol, then open the file with the given mode;
+    otherwise, delegate to ``urllib2.urlopen``.
+
+    :type resource_url: str
+    :param resource_url: A URL specifying where the resource should be
+        loaded from.  The default protocol is "nltk:", which searches
+        for the file in the the NLTK data package.
+    """
+    resource_url = normalize_resource_url(resource_url)
+    protocol, path_ = split_resource_url(resource_url)
+
+    if protocol is None or protocol.lower() == "nltk":
+        return find(path_, path + [""]).open()
+    elif protocol.lower() == "file":
+        # urllib might not use mode='rb', so handle this one ourselves:
+        return find(path_, [""]).open()
+    else:
+        return urlopen(resource_url)
+
+
+######################################################################
+# Lazy Resource Loader
+######################################################################
+
+
+class LazyLoader:
+    @py3_data
+    def __init__(self, _path):
+        self._path = _path
+
+    def __load(self):
+        resource = load(self._path)
+        # This is where the magic happens!  Transform ourselves into
+        # the object by modifying our own __dict__ and __class__ to
+        # match that of `resource`.
+        self.__dict__ = resource.__dict__
+        self.__class__ = resource.__class__
+
+    def __getattr__(self, attr):
+        self.__load()
+        # This looks circular, but its not, since __load() changes our
+        # __class__ to something new:
+        return getattr(self, attr)
+
+    def __repr__(self):
+        self.__load()
+        # This looks circular, but its not, since __load() changes our
+        # __class__ to something new:
+        return repr(self)
+
+
+######################################################################
+# Open-On-Demand ZipFile
+######################################################################
+
+
+class OpenOnDemandZipFile(zipfile.ZipFile):
+    """
+    A subclass of ``zipfile.ZipFile`` that closes its file pointer
+    whenever it is not using it; and re-opens it when it needs to read
+    data from the zipfile.  This is useful for reducing the number of
+    open file handles when many zip files are being accessed at once.
+    ``OpenOnDemandZipFile`` must be constructed from a filename, not a
+    file-like object (to allow re-opening).  ``OpenOnDemandZipFile`` is
+    read-only (i.e. ``write()`` and ``writestr()`` are disabled.
+    """
+
+    @py3_data
+    def __init__(self, filename):
+        if not isinstance(filename, str):
+            raise TypeError("ReopenableZipFile filename must be a string")
+        zipfile.ZipFile.__init__(self, filename)
+        assert self.filename == filename
+        self.close()
+        # After closing a ZipFile object, the _fileRefCnt needs to be cleared
+        # for Python2and3 compatible code.
+        self._fileRefCnt = 0
+
+    def read(self, name):
+        assert self.fp is None
+        self.fp = open(self.filename, "rb")
+        value = zipfile.ZipFile.read(self, name)
+        # Ensure that _fileRefCnt needs to be set for Python2and3 compatible code.
+        # Since we only opened one file here, we add 1.
+        self._fileRefCnt += 1
+        self.close()
+        return value
+
+    def write(self, *args, **kwargs):
+        """:raise NotImplementedError: OpenOnDemandZipfile is read-only"""
+        raise NotImplementedError("OpenOnDemandZipfile is read-only")
+
+    def writestr(self, *args, **kwargs):
+        """:raise NotImplementedError: OpenOnDemandZipfile is read-only"""
+        raise NotImplementedError("OpenOnDemandZipfile is read-only")
+
+    def __repr__(self):
+        return repr("OpenOnDemandZipFile(%r)" % self.filename)
+
+
+######################################################################
+# Seekable Unicode Stream Reader
+######################################################################
+
+
+class SeekableUnicodeStreamReader:
+    """
+    A stream reader that automatically encodes the source byte stream
+    into unicode (like ``codecs.StreamReader``); but still supports the
+    ``seek()`` and ``tell()`` operations correctly.  This is in contrast
+    to ``codecs.StreamReader``, which provide *broken* ``seek()`` and
+    ``tell()`` methods.
+
+    This class was motivated by ``StreamBackedCorpusView``, which
+    makes extensive use of ``seek()`` and ``tell()``, and needs to be
+    able to handle unicode-encoded files.
+
+    Note: this class requires stateless decoders.  To my knowledge,
+    this shouldn't cause a problem with any of python's builtin
+    unicode encodings.
+    """
+
+    DEBUG = True  # : If true, then perform extra sanity checks.
+
+    @py3_data
+    def __init__(self, stream, encoding, errors="strict"):
+        # Rewind the stream to its beginning.
+        stream.seek(0)
+
+        self.stream = stream
+        """The underlying stream."""
+
+        self.encoding = encoding
+        """The name of the encoding that should be used to encode the
+           underlying stream."""
+
+        self.errors = errors
+        """The error mode that should be used when decoding data from
+           the underlying stream.  Can be 'strict', 'ignore', or
+           'replace'."""
+
+        self.decode = codecs.getdecoder(encoding)
+        """The function that is used to decode byte strings into
+           unicode strings."""
+
+        self.bytebuffer = b""
+        """A buffer to use bytes that have been read but have not yet
+           been decoded.  This is only used when the final bytes from
+           a read do not form a complete encoding for a character."""
+
+        self.linebuffer = None
+        """A buffer used by ``readline()`` to hold characters that have
+           been read, but have not yet been returned by ``read()`` or
+           ``readline()``.  This buffer consists of a list of unicode
+           strings, where each string corresponds to a single line.
+           The final element of the list may or may not be a complete
+           line.  Note that the existence of a linebuffer makes the
+           ``tell()`` operation more complex, because it must backtrack
+           to the beginning of the buffer to determine the correct
+           file position in the underlying byte stream."""
+
+        self._rewind_checkpoint = 0
+        """The file position at which the most recent read on the
+           underlying stream began.  This is used, together with
+           ``_rewind_numchars``, to backtrack to the beginning of
+           ``linebuffer`` (which is required by ``tell()``)."""
+
+        self._rewind_numchars = None
+        """The number of characters that have been returned since the
+           read that started at ``_rewind_checkpoint``.  This is used,
+           together with ``_rewind_checkpoint``, to backtrack to the
+           beginning of ``linebuffer`` (which is required by ``tell()``)."""
+
+        self._bom = self._check_bom()
+        """The length of the byte order marker at the beginning of
+           the stream (or None for no byte order marker)."""
+
+    # /////////////////////////////////////////////////////////////////
+    # Read methods
+    # /////////////////////////////////////////////////////////////////
+
+    def read(self, size=None):
+        """
+        Read up to ``size`` bytes, decode them using this reader's
+        encoding, and return the resulting unicode string.
+
+        :param size: The maximum number of bytes to read.  If not
+            specified, then read as many bytes as possible.
+        :type size: int
+        :rtype: unicode
+        """
+        chars = self._read(size)
+
+        # If linebuffer is not empty, then include it in the result
+        if self.linebuffer:
+            chars = "".join(self.linebuffer) + chars
+            self.linebuffer = None
+            self._rewind_numchars = None
+
+        return chars
+
+    def discard_line(self):
+        if self.linebuffer and len(self.linebuffer) > 1:
+            line = self.linebuffer.pop(0)
+            self._rewind_numchars += len(line)
+        else:
+            self.stream.readline()
+
+    def readline(self, size=None):
+        """
+        Read a line of text, decode it using this reader's encoding,
+        and return the resulting unicode string.
+
+        :param size: The maximum number of bytes to read.  If no
+            newline is encountered before ``size`` bytes have been read,
+            then the returned value may not be a complete line of text.
+        :type size: int
+        """
+        # If we have a non-empty linebuffer, then return the first
+        # line from it.  (Note that the last element of linebuffer may
+        # not be a complete line; so let _read() deal with it.)
+        if self.linebuffer and len(self.linebuffer) > 1:
+            line = self.linebuffer.pop(0)
+            self._rewind_numchars += len(line)
+            return line
+
+        readsize = size or 72
+        chars = ""
+
+        # If there's a remaining incomplete line in the buffer, add it.
+        if self.linebuffer:
+            chars += self.linebuffer.pop()
+            self.linebuffer = None
+
+        while True:
+            startpos = self.stream.tell() - len(self.bytebuffer)
+            new_chars = self._read(readsize)
+
+            # If we're at a '\r', then read one extra character, since
+            # it might be a '\n', to get the proper line ending.
+            if new_chars and new_chars.endswith("\r"):
+                new_chars += self._read(1)
+
+            chars += new_chars
+            lines = chars.splitlines(True)
+            if len(lines) > 1:
+                line = lines[0]
+                self.linebuffer = lines[1:]
+                self._rewind_numchars = len(new_chars) - (len(chars) - len(line))
+                self._rewind_checkpoint = startpos
+                break
+            elif len(lines) == 1:
+                line0withend = lines[0]
+                line0withoutend = lines[0].splitlines(False)[0]
+                if line0withend != line0withoutend:  # complete line
+                    line = line0withend
+                    break
+
+            if not new_chars or size is not None:
+                line = chars
+                break
+
+            # Read successively larger blocks of text.
+            if readsize < 8000:
+                readsize *= 2
+
+        return line
+
+    def readlines(self, sizehint=None, keepends=True):
+        """
+        Read this file's contents, decode them using this reader's
+        encoding, and return it as a list of unicode lines.
+
+        :rtype: list(unicode)
+        :param sizehint: Ignored.
+        :param keepends: If false, then strip newlines.
+        """
+        return self.read().splitlines(keepends)
+
+    def next(self):
+        """Return the next decoded line from the underlying stream."""
+        line = self.readline()
+        if line:
+            return line
+        else:
+            raise StopIteration
+
+    def __next__(self):
+        return self.next()
+
+    def __iter__(self):
+        """Return self"""
+        return self
+
+    def __del__(self):
+        # let garbage collector deal with still opened streams
+        if not self.closed:
+            self.close()
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, type, value, traceback):
+        self.close()
+
+    def xreadlines(self):
+        """Return self"""
+        return self
+
+    # /////////////////////////////////////////////////////////////////
+    # Pass-through methods & properties
+    # /////////////////////////////////////////////////////////////////
+
+    @property
+    def closed(self):
+        """True if the underlying stream is closed."""
+        return self.stream.closed
+
+    @property
+    def name(self):
+        """The name of the underlying stream."""
+        return self.stream.name
+
+    @property
+    def mode(self):
+        """The mode of the underlying stream."""
+        return self.stream.mode
+
+    def close(self):
+        """
+        Close the underlying stream.
+        """
+        self.stream.close()
+
+    # /////////////////////////////////////////////////////////////////
+    # Seek and tell
+    # /////////////////////////////////////////////////////////////////
+
+    def seek(self, offset, whence=0):
+        """
+        Move the stream to a new file position.  If the reader is
+        maintaining any buffers, then they will be cleared.
+
+        :param offset: A byte count offset.
+        :param whence: If 0, then the offset is from the start of the file
+            (offset should be positive), if 1, then the offset is from the
+            current position (offset may be positive or negative); and if 2,
+            then the offset is from the end of the file (offset should
+            typically be negative).
+        """
+        if whence == 1:
+            raise ValueError(
+                "Relative seek is not supported for "
+                "SeekableUnicodeStreamReader -- consider "
+                "using char_seek_forward() instead."
+            )
+        self.stream.seek(offset, whence)
+        self.linebuffer = None
+        self.bytebuffer = b""
+        self._rewind_numchars = None
+        self._rewind_checkpoint = self.stream.tell()
+
+    def char_seek_forward(self, offset):
+        """
+        Move the read pointer forward by ``offset`` characters.
+        """
+        if offset < 0:
+            raise ValueError("Negative offsets are not supported")
+        # Clear all buffers.
+        self.seek(self.tell())
+        # Perform the seek operation.
+        self._char_seek_forward(offset)
+
+    def _char_seek_forward(self, offset, est_bytes=None):
+        """
+        Move the file position forward by ``offset`` characters,
+        ignoring all buffers.
+
+        :param est_bytes: A hint, giving an estimate of the number of
+            bytes that will be needed to move forward by ``offset`` chars.
+            Defaults to ``offset``.
+        """
+        if est_bytes is None:
+            est_bytes = offset
+        bytes = b""
+
+        while True:
+            # Read in a block of bytes.
+            newbytes = self.stream.read(est_bytes - len(bytes))
+            bytes += newbytes
+
+            # Decode the bytes to characters.
+            chars, bytes_decoded = self._incr_decode(bytes)
+
+            # If we got the right number of characters, then seek
+            # backwards over any truncated characters, and return.
+            if len(chars) == offset:
+                self.stream.seek(-len(bytes) + bytes_decoded, 1)
+                return
+
+            # If we went too far, then we can back-up until we get it
+            # right, using the bytes we've already read.
+            if len(chars) > offset:
+                while len(chars) > offset:
+                    # Assume at least one byte/char.
+                    est_bytes += offset - len(chars)
+                    chars, bytes_decoded = self._incr_decode(bytes[:est_bytes])
+                self.stream.seek(-len(bytes) + bytes_decoded, 1)
+                return
+
+            # Otherwise, we haven't read enough bytes yet; loop again.
+            est_bytes += offset - len(chars)
+
+    def tell(self):
+        """
+        Return the current file position on the underlying byte
+        stream.  If this reader is maintaining any buffers, then the
+        returned file position will be the position of the beginning
+        of those buffers.
+        """
+        # If nothing's buffered, then just return our current filepos:
+        if self.linebuffer is None:
+            return self.stream.tell() - len(self.bytebuffer)
+
+        # Otherwise, we'll need to backtrack the filepos until we
+        # reach the beginning of the buffer.
+
+        # Store our original file position, so we can return here.
+        orig_filepos = self.stream.tell()
+
+        # Calculate an estimate of where we think the newline is.
+        bytes_read = (orig_filepos - len(self.bytebuffer)) - self._rewind_checkpoint
+        buf_size = sum(len(line) for line in self.linebuffer)
+        est_bytes = int(
+            bytes_read * self._rewind_numchars / (self._rewind_numchars + buf_size)
+        )
+
+        self.stream.seek(self._rewind_checkpoint)
+        self._char_seek_forward(self._rewind_numchars, est_bytes)
+        filepos = self.stream.tell()
+
+        # Sanity check
+        if self.DEBUG:
+            self.stream.seek(filepos)
+            check1 = self._incr_decode(self.stream.read(50))[0]
+            check2 = "".join(self.linebuffer)
+            assert check1.startswith(check2) or check2.startswith(check1)
+
+        # Return to our original filepos (so we don't have to throw
+        # out our buffer.)
+        self.stream.seek(orig_filepos)
+
+        # Return the calculated filepos
+        return filepos
+
+    # /////////////////////////////////////////////////////////////////
+    # Helper methods
+    # /////////////////////////////////////////////////////////////////
+
+    def _read(self, size=None):
+        """
+        Read up to ``size`` bytes from the underlying stream, decode
+        them using this reader's encoding, and return the resulting
+        unicode string.  ``linebuffer`` is not included in the result.
+        """
+        if size == 0:
+            return ""
+
+        # Skip past the byte order marker, if present.
+        if self._bom and self.stream.tell() == 0:
+            self.stream.read(self._bom)
+
+        # Read the requested number of bytes.
+        if size is None:
+            new_bytes = self.stream.read()
+        else:
+            new_bytes = self.stream.read(size)
+        bytes = self.bytebuffer + new_bytes
+
+        # Decode the bytes into unicode characters
+        chars, bytes_decoded = self._incr_decode(bytes)
+
+        # If we got bytes but couldn't decode any, then read further.
+        if (size is not None) and (not chars) and (len(new_bytes) > 0):
+            while not chars:
+                new_bytes = self.stream.read(1)
+                if not new_bytes:
+                    break  # end of file.
+                bytes += new_bytes
+                chars, bytes_decoded = self._incr_decode(bytes)
+
+        # Record any bytes we didn't consume.
+        self.bytebuffer = bytes[bytes_decoded:]
+
+        # Return the result
+        return chars
+
+    def _incr_decode(self, bytes):
+        """
+        Decode the given byte string into a unicode string, using this
+        reader's encoding.  If an exception is encountered that
+        appears to be caused by a truncation error, then just decode
+        the byte string without the bytes that cause the trunctaion
+        error.
+
+        Return a tuple ``(chars, num_consumed)``, where ``chars`` is
+        the decoded unicode string, and ``num_consumed`` is the
+        number of bytes that were consumed.
+        """
+        while True:
+            try:
+                return self.decode(bytes, "strict")
+            except UnicodeDecodeError as exc:
+                # If the exception occurs at the end of the string,
+                # then assume that it's a truncation error.
+                if exc.end == len(bytes):
+                    return self.decode(bytes[: exc.start], self.errors)
+
+                # Otherwise, if we're being strict, then raise it.
+                elif self.errors == "strict":
+                    raise
+
+                # If we're not strict, then re-process it with our
+                # errors setting.  This *may* raise an exception.
+                else:
+                    return self.decode(bytes, self.errors)
+
+    _BOM_TABLE = {
+        "utf8": [(codecs.BOM_UTF8, None)],
+        "utf16": [(codecs.BOM_UTF16_LE, "utf16-le"), (codecs.BOM_UTF16_BE, "utf16-be")],
+        "utf16le": [(codecs.BOM_UTF16_LE, None)],
+        "utf16be": [(codecs.BOM_UTF16_BE, None)],
+        "utf32": [(codecs.BOM_UTF32_LE, "utf32-le"), (codecs.BOM_UTF32_BE, "utf32-be")],
+        "utf32le": [(codecs.BOM_UTF32_LE, None)],
+        "utf32be": [(codecs.BOM_UTF32_BE, None)],
+    }
+
+    def _check_bom(self):
+        # Normalize our encoding name
+        enc = re.sub("[ -]", "", self.encoding.lower())
+
+        # Look up our encoding in the BOM table.
+        bom_info = self._BOM_TABLE.get(enc)
+
+        if bom_info:
+            # Read a prefix, to check against the BOM(s)
+            bytes = self.stream.read(16)
+            self.stream.seek(0)
+
+            # Check for each possible BOM.
+            for (bom, new_encoding) in bom_info:
+                if bytes.startswith(bom):
+                    if new_encoding:
+                        self.encoding = new_encoding
+                    return len(bom)
+
+        return None
+
+
+__all__ = [
+    "path",
+    "PathPointer",
+    "FileSystemPathPointer",
+    "BufferedGzipFile",
+    "GzipFileSystemPathPointer",
+    "GzipFileSystemPathPointer",
+    "find",
+    "retrieve",
+    "FORMATS",
+    "AUTO_FORMATS",
+    "load",
+    "show_cfg",
+    "clear_cache",
+    "LazyLoader",
+    "OpenOnDemandZipFile",
+    "GzipFileSystemPathPointer",
+    "SeekableUnicodeStreamReader",
+]

llmeval-env/lib/python3.10/site-packages/nltk/decorators.py

@@ -0,0 +1,251 @@
+"""
+Decorator module by Michele Simionato <[email protected]>
+Copyright Michele Simionato, distributed under the terms of the BSD License (see below).
+http://www.phyast.pitt.edu/~micheles/python/documentation.html
+
+Included in NLTK for its support of a nice memoization decorator.
+"""
+
+__docformat__ = "restructuredtext en"
+
+## The basic trick is to generate the source code for the decorated function
+## with the right signature and to evaluate it.
+## Uncomment the statement 'print >> sys.stderr, func_src'  in _decorator
+## to understand what is going on.
+
+__all__ = ["decorator", "new_wrapper", "getinfo"]
+
+import sys
+
+# Hack to keep NLTK's "tokenize" module from colliding with the "tokenize" in
+# the Python standard library.
+OLD_SYS_PATH = sys.path[:]
+sys.path = [p for p in sys.path if p and "nltk" not in str(p)]
+import inspect
+
+sys.path = OLD_SYS_PATH
+
+
+def __legacysignature(signature):
+    """
+    For retrocompatibility reasons, we don't use a standard Signature.
+    Instead, we use the string generated by this method.
+    Basically, from a Signature we create a string and remove the default values.
+    """
+    listsignature = str(signature)[1:-1].split(",")
+    for counter, param in enumerate(listsignature):
+        if param.count("=") > 0:
+            listsignature[counter] = param[0 : param.index("=")].strip()
+        else:
+            listsignature[counter] = param.strip()
+    return ", ".join(listsignature)
+
+
+def getinfo(func):
+    """
+    Returns an info dictionary containing:
+    - name (the name of the function : str)
+    - argnames (the names of the arguments : list)
+    - defaults (the values of the default arguments : tuple)
+    - signature (the signature : str)
+    - fullsignature (the full signature : Signature)
+    - doc (the docstring : str)
+    - module (the module name : str)
+    - dict (the function __dict__ : str)
+
+    >>> def f(self, x=1, y=2, *args, **kw): pass
+
+    >>> info = getinfo(f)
+
+    >>> info["name"]
+    'f'
+    >>> info["argnames"]
+    ['self', 'x', 'y', 'args', 'kw']
+
+    >>> info["defaults"]
+    (1, 2)
+
+    >>> info["signature"]
+    'self, x, y, *args, **kw'
+
+    >>> info["fullsignature"]
+    <Signature (self, x=1, y=2, *args, **kw)>
+    """
+    assert inspect.ismethod(func) or inspect.isfunction(func)
+    argspec = inspect.getfullargspec(func)
+    regargs, varargs, varkwargs = argspec[:3]
+    argnames = list(regargs)
+    if varargs:
+        argnames.append(varargs)
+    if varkwargs:
+        argnames.append(varkwargs)
+    fullsignature = inspect.signature(func)
+    # Convert Signature to str
+    signature = __legacysignature(fullsignature)
+
+    # pypy compatibility
+    if hasattr(func, "__closure__"):
+        _closure = func.__closure__
+        _globals = func.__globals__
+    else:
+        _closure = func.func_closure
+        _globals = func.func_globals
+
+    return dict(
+        name=func.__name__,
+        argnames=argnames,
+        signature=signature,
+        fullsignature=fullsignature,
+        defaults=func.__defaults__,
+        doc=func.__doc__,
+        module=func.__module__,
+        dict=func.__dict__,
+        globals=_globals,
+        closure=_closure,
+    )
+
+
+def update_wrapper(wrapper, model, infodict=None):
+    "akin to functools.update_wrapper"
+    infodict = infodict or getinfo(model)
+    wrapper.__name__ = infodict["name"]
+    wrapper.__doc__ = infodict["doc"]
+    wrapper.__module__ = infodict["module"]
+    wrapper.__dict__.update(infodict["dict"])
+    wrapper.__defaults__ = infodict["defaults"]
+    wrapper.undecorated = model
+    return wrapper
+
+
+def new_wrapper(wrapper, model):
+    """
+    An improvement over functools.update_wrapper. The wrapper is a generic
+    callable object. It works by generating a copy of the wrapper with the
+    right signature and by updating the copy, not the original.
+    Moreovoer, 'model' can be a dictionary with keys 'name', 'doc', 'module',
+    'dict', 'defaults'.
+    """
+    if isinstance(model, dict):
+        infodict = model
+    else:  # assume model is a function
+        infodict = getinfo(model)
+    assert (
+        not "_wrapper_" in infodict["argnames"]
+    ), '"_wrapper_" is a reserved argument name!'
+    src = "lambda %(signature)s: _wrapper_(%(signature)s)" % infodict
+    funcopy = eval(src, dict(_wrapper_=wrapper))
+    return update_wrapper(funcopy, model, infodict)
+
+
+# helper used in decorator_factory
+def __call__(self, func):
+    return new_wrapper(lambda *a, **k: self.call(func, *a, **k), func)
+
+
+def decorator_factory(cls):
+    """
+    Take a class with a ``.caller`` method and return a callable decorator
+    object. It works by adding a suitable __call__ method to the class;
+    it raises a TypeError if the class already has a nontrivial __call__
+    method.
+    """
+    attrs = set(dir(cls))
+    if "__call__" in attrs:
+        raise TypeError(
+            "You cannot decorate a class with a nontrivial " "__call__ method"
+        )
+    if "call" not in attrs:
+        raise TypeError("You cannot decorate a class without a " ".call method")
+    cls.__call__ = __call__
+    return cls
+
+
+def decorator(caller):
+    """
+    General purpose decorator factory: takes a caller function as
+    input and returns a decorator with the same attributes.
+    A caller function is any function like this::
+
+     def caller(func, *args, **kw):
+         # do something
+         return func(*args, **kw)
+
+    Here is an example of usage:
+
+    >>> @decorator
+    ... def chatty(f, *args, **kw):
+    ...     print("Calling %r" % f.__name__)
+    ...     return f(*args, **kw)
+
+    >>> chatty.__name__
+    'chatty'
+
+    >>> @chatty
+    ... def f(): pass
+    ...
+    >>> f()
+    Calling 'f'
+
+    decorator can also take in input a class with a .caller method; in this
+    case it converts the class into a factory of callable decorator objects.
+    See the documentation for an example.
+    """
+    if inspect.isclass(caller):
+        return decorator_factory(caller)
+
+    def _decorator(func):  # the real meat is here
+        infodict = getinfo(func)
+        argnames = infodict["argnames"]
+        assert not (
+            "_call_" in argnames or "_func_" in argnames
+        ), "You cannot use _call_ or _func_ as argument names!"
+        src = "lambda %(signature)s: _call_(_func_, %(signature)s)" % infodict
+        # import sys; print >> sys.stderr, src # for debugging purposes
+        dec_func = eval(src, dict(_func_=func, _call_=caller))
+        return update_wrapper(dec_func, func, infodict)
+
+    return update_wrapper(_decorator, caller)
+
+
+def getattr_(obj, name, default_thunk):
+    "Similar to .setdefault in dictionaries."
+    try:
+        return getattr(obj, name)
+    except AttributeError:
+        default = default_thunk()
+        setattr(obj, name, default)
+        return default
+
+
+@decorator
+def memoize(func, *args):
+    dic = getattr_(func, "memoize_dic", dict)
+    # memoize_dic is created at the first call
+    if args in dic:
+        return dic[args]
+    result = func(*args)
+    dic[args] = result
+    return result
+
+
+##########################     LEGALESE    ###############################
+
+##   Redistributions of source code must retain the above copyright
+##   notice, this list of conditions and the following disclaimer.
+##   Redistributions in bytecode form must reproduce the above copyright
+##   notice, this list of conditions and the following disclaimer in
+##   the documentation and/or other materials provided with the
+##   distribution.
+
+##   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+##   "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+##   LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+##   A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+##   HOLDERS OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
+##   INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
+##   BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS
+##   OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+##   ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR
+##   TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE
+##   USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH
+##   DAMAGE.

llmeval-env/lib/python3.10/site-packages/nltk/downloader.py

@@ -0,0 +1,2559 @@
+# Natural Language Toolkit: Corpus & Model Downloader
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+The NLTK corpus and module downloader.  This module defines several
+interfaces which can be used to download corpora, models, and other
+data packages that can be used with NLTK.
+
+Downloading Packages
+====================
+If called with no arguments, ``download()`` will display an interactive
+interface which can be used to download and install new packages.
+If Tkinter is available, then a graphical interface will be shown,
+otherwise a simple text interface will be provided.
+
+Individual packages can be downloaded by calling the ``download()``
+function with a single argument, giving the package identifier for the
+package that should be downloaded:
+
+    >>> download('treebank') # doctest: +SKIP
+    [nltk_data] Downloading package 'treebank'...
+    [nltk_data]   Unzipping corpora/treebank.zip.
+
+NLTK also provides a number of \"package collections\", consisting of
+a group of related packages.  To download all packages in a
+colleciton, simply call ``download()`` with the collection's
+identifier:
+
+    >>> download('all-corpora') # doctest: +SKIP
+    [nltk_data] Downloading package 'abc'...
+    [nltk_data]   Unzipping corpora/abc.zip.
+    [nltk_data] Downloading package 'alpino'...
+    [nltk_data]   Unzipping corpora/alpino.zip.
+      ...
+    [nltk_data] Downloading package 'words'...
+    [nltk_data]   Unzipping corpora/words.zip.
+
+Download Directory
+==================
+By default, packages are installed in either a system-wide directory
+(if Python has sufficient access to write to it); or in the current
+user's home directory.  However, the ``download_dir`` argument may be
+used to specify a different installation target, if desired.
+
+See ``Downloader.default_download_dir()`` for more a detailed
+description of how the default download directory is chosen.
+
+NLTK Download Server
+====================
+Before downloading any packages, the corpus and module downloader
+contacts the NLTK download server, to retrieve an index file
+describing the available packages.  By default, this index file is
+loaded from ``https://raw.githubusercontent.com/nltk/nltk_data/gh-pages/index.xml``.
+If necessary, it is possible to create a new ``Downloader`` object,
+specifying a different URL for the package index file.
+
+Usage::
+
+    python nltk/downloader.py [-d DATADIR] [-q] [-f] [-k] PACKAGE_IDS
+
+or::
+
+    python -m nltk.downloader [-d DATADIR] [-q] [-f] [-k] PACKAGE_IDS
+"""
+# ----------------------------------------------------------------------
+
+"""
+
+  0     1  2    3
+[label][----][label][----]
+[column  ][column     ]
+
+Notes
+=====
+Handling data files..  Some questions:
+
+* Should the data files be kept zipped or unzipped?  I say zipped.
+
+* Should the data files be kept in svn at all?  Advantages: history;
+  automatic version numbers; 'svn up' could be used rather than the
+  downloader to update the corpora.  Disadvantages: they're big,
+  which makes working from svn a bit of a pain.  And we're planning
+  to potentially make them much bigger.  I don't think we want
+  people to have to download 400MB corpora just to use nltk from svn.
+
+* Compromise: keep the data files in trunk/data rather than in
+  trunk/nltk.  That way you can check them out in svn if you want
+  to; but you don't need to, and you can use the downloader instead.
+
+* Also: keep models in mind.  When we change the code, we'd
+  potentially like the models to get updated.  This could require a
+  little thought.
+
+* So.. let's assume we have a trunk/data directory, containing a bunch
+  of packages.  The packages should be kept as zip files, because we
+  really shouldn't be editing them much (well -- we may edit models
+  more, but they tend to be binary-ish files anyway, where diffs
+  aren't that helpful).  So we'll have trunk/data, with a bunch of
+  files like abc.zip and treebank.zip and propbank.zip.  For each
+  package we could also have eg treebank.xml and propbank.xml,
+  describing the contents of the package (name, copyright, license,
+  etc).  Collections would also have .xml files.  Finally, we would
+  pull all these together to form a single index.xml file.  Some
+  directory structure wouldn't hurt.  So how about::
+
+    /trunk/data/ ....................... root of data svn
+      index.xml ........................ main index file
+      src/ ............................. python scripts
+      packages/ ........................ dir for packages
+        corpora/ ....................... zip & xml files for corpora
+        grammars/ ...................... zip & xml files for grammars
+        taggers/ ....................... zip & xml files for taggers
+        tokenizers/ .................... zip & xml files for tokenizers
+        etc.
+      collections/ ..................... xml files for collections
+
+  Where the root (/trunk/data) would contain a makefile; and src/
+  would contain a script to update the info.xml file.  It could also
+  contain scripts to rebuild some of the various model files.  The
+  script that builds index.xml should probably check that each zip
+  file expands entirely into a single subdir, whose name matches the
+  package's uid.
+
+Changes I need to make:
+  - in index: change "size" to "filesize" or "compressed-size"
+  - in index: add "unzipped-size"
+  - when checking status: check both compressed & uncompressed size.
+    uncompressed size is important to make sure we detect a problem
+    if something got partially unzipped.  define new status values
+    to differentiate stale vs corrupt vs corruptly-uncompressed??
+    (we shouldn't need to re-download the file if the zip file is ok
+    but it didn't get uncompressed fully.)
+  - add other fields to the index: author, license, copyright, contact,
+    etc.
+
+the current grammars/ package would become a single new package (eg
+toy-grammars or book-grammars).
+
+xml file should have:
+  - authorship info
+  - license info
+  - copyright info
+  - contact info
+  - info about what type of data/annotation it contains?
+  - recommended corpus reader?
+
+collections can contain other collections.  they can also contain
+multiple package types (corpora & models).  Have a single 'basics'
+package that includes everything we talk about in the book?
+
+n.b.: there will have to be a fallback to the punkt tokenizer, in case
+they didn't download that model.
+
+default: unzip or not?
+
+"""
+import functools
+import itertools
+import os
+import shutil
+import subprocess
+import sys
+import textwrap
+import threading
+import time
+import warnings
+import zipfile
+from hashlib import md5
+from xml.etree import ElementTree
+
+try:
+    TKINTER = True
+    from tkinter import Button, Canvas, Entry, Frame, IntVar, Label, Menu, TclError, Tk
+    from tkinter.messagebox import showerror
+
+    from nltk.draw.table import Table
+    from nltk.draw.util import ShowText
+except ImportError:
+    TKINTER = False
+    TclError = ValueError
+
+from urllib.error import HTTPError, URLError
+from urllib.request import urlopen
+
+import nltk
+
+# urllib2 = nltk.internals.import_from_stdlib('urllib2')
+
+
+######################################################################
+# Directory entry objects (from the data server's index file)
+######################################################################
+
+
+class Package:
+    """
+    A directory entry for a downloadable package.  These entries are
+    extracted from the XML index file that is downloaded by
+    ``Downloader``.  Each package consists of a single file; but if
+    that file is a zip file, then it can be automatically decompressed
+    when the package is installed.
+    """
+
+    def __init__(
+        self,
+        id,
+        url,
+        name=None,
+        subdir="",
+        size=None,
+        unzipped_size=None,
+        checksum=None,
+        svn_revision=None,
+        copyright="Unknown",
+        contact="Unknown",
+        license="Unknown",
+        author="Unknown",
+        unzip=True,
+        **kw,
+    ):
+        self.id = id
+        """A unique identifier for this package."""
+
+        self.name = name or id
+        """A string name for this package."""
+
+        self.subdir = subdir
+        """The subdirectory where this package should be installed.
+           E.g., ``'corpora'`` or ``'taggers'``."""
+
+        self.url = url
+        """A URL that can be used to download this package's file."""
+
+        self.size = int(size)
+        """The filesize (in bytes) of the package file."""
+
+        self.unzipped_size = int(unzipped_size)
+        """The total filesize of the files contained in the package's
+           zipfile."""
+
+        self.checksum = checksum
+        """The MD-5 checksum of the package file."""
+
+        self.svn_revision = svn_revision
+        """A subversion revision number for this package."""
+
+        self.copyright = copyright
+        """Copyright holder for this package."""
+
+        self.contact = contact
+        """Name & email of the person who should be contacted with
+           questions about this package."""
+
+        self.license = license
+        """License information for this package."""
+
+        self.author = author
+        """Author of this package."""
+
+        ext = os.path.splitext(url.split("/")[-1])[1]
+        self.filename = os.path.join(subdir, id + ext)
+        """The filename that should be used for this package's file.  It
+           is formed by joining ``self.subdir`` with ``self.id``, and
+           using the same extension as ``url``."""
+
+        self.unzip = bool(int(unzip))  # '0' or '1'
+        """A flag indicating whether this corpus should be unzipped by
+           default."""
+
+        # Include any other attributes provided by the XML file.
+        self.__dict__.update(kw)
+
+    @staticmethod
+    def fromxml(xml):
+        if isinstance(xml, str):
+            xml = ElementTree.parse(xml)
+        for key in xml.attrib:
+            xml.attrib[key] = str(xml.attrib[key])
+        return Package(**xml.attrib)
+
+    def __lt__(self, other):
+        return self.id < other.id
+
+    def __repr__(self):
+        return "<Package %s>" % self.id
+
+
+class Collection:
+    """
+    A directory entry for a collection of downloadable packages.
+    These entries are extracted from the XML index file that is
+    downloaded by ``Downloader``.
+    """
+
+    def __init__(self, id, children, name=None, **kw):
+        self.id = id
+        """A unique identifier for this collection."""
+
+        self.name = name or id
+        """A string name for this collection."""
+
+        self.children = children
+        """A list of the ``Collections`` or ``Packages`` directly
+           contained by this collection."""
+
+        self.packages = None
+        """A list of ``Packages`` contained by this collection or any
+           collections it recursively contains."""
+
+        # Include any other attributes provided by the XML file.
+        self.__dict__.update(kw)
+
+    @staticmethod
+    def fromxml(xml):
+        if isinstance(xml, str):
+            xml = ElementTree.parse(xml)
+        for key in xml.attrib:
+            xml.attrib[key] = str(xml.attrib[key])
+        children = [child.get("ref") for child in xml.findall("item")]
+        return Collection(children=children, **xml.attrib)
+
+    def __lt__(self, other):
+        return self.id < other.id
+
+    def __repr__(self):
+        return "<Collection %s>" % self.id
+
+
+######################################################################
+# Message Passing Objects
+######################################################################
+
+
+class DownloaderMessage:
+    """A status message object, used by ``incr_download`` to
+    communicate its progress."""
+
+
+class StartCollectionMessage(DownloaderMessage):
+    """Data server has started working on a collection of packages."""
+
+    def __init__(self, collection):
+        self.collection = collection
+
+
+class FinishCollectionMessage(DownloaderMessage):
+    """Data server has finished working on a collection of packages."""
+
+    def __init__(self, collection):
+        self.collection = collection
+
+
+class StartPackageMessage(DownloaderMessage):
+    """Data server has started working on a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class FinishPackageMessage(DownloaderMessage):
+    """Data server has finished working on a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class StartDownloadMessage(DownloaderMessage):
+    """Data server has started downloading a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class FinishDownloadMessage(DownloaderMessage):
+    """Data server has finished downloading a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class StartUnzipMessage(DownloaderMessage):
+    """Data server has started unzipping a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class FinishUnzipMessage(DownloaderMessage):
+    """Data server has finished unzipping a package."""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class UpToDateMessage(DownloaderMessage):
+    """The package download file is already up-to-date"""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class StaleMessage(DownloaderMessage):
+    """The package download file is out-of-date or corrupt"""
+
+    def __init__(self, package):
+        self.package = package
+
+
+class ErrorMessage(DownloaderMessage):
+    """Data server encountered an error"""
+
+    def __init__(self, package, message):
+        self.package = package
+        if isinstance(message, Exception):
+            self.message = str(message)
+        else:
+            self.message = message
+
+
+class ProgressMessage(DownloaderMessage):
+    """Indicates how much progress the data server has made"""
+
+    def __init__(self, progress):
+        self.progress = progress
+
+
+class SelectDownloadDirMessage(DownloaderMessage):
+    """Indicates what download directory the data server is using"""
+
+    def __init__(self, download_dir):
+        self.download_dir = download_dir
+
+
+######################################################################
+# NLTK Data Server
+######################################################################
+
+
+class Downloader:
+    """
+    A class used to access the NLTK data server, which can be used to
+    download corpora and other data packages.
+    """
+
+    # /////////////////////////////////////////////////////////////////
+    # Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    INDEX_TIMEOUT = 60 * 60  # 1 hour
+    """The amount of time after which the cached copy of the data
+       server index will be considered 'stale,' and will be
+       re-downloaded."""
+
+    DEFAULT_URL = "https://raw.githubusercontent.com/nltk/nltk_data/gh-pages/index.xml"
+    """The default URL for the NLTK data server's index.  An
+       alternative URL can be specified when creating a new
+       ``Downloader`` object."""
+
+    # /////////////////////////////////////////////////////////////////
+    # Status Constants
+    # /////////////////////////////////////////////////////////////////
+
+    INSTALLED = "installed"
+    """A status string indicating that a package or collection is
+       installed and up-to-date."""
+    NOT_INSTALLED = "not installed"
+    """A status string indicating that a package or collection is
+       not installed."""
+    STALE = "out of date"
+    """A status string indicating that a package or collection is
+       corrupt or out-of-date."""
+    PARTIAL = "partial"
+    """A status string indicating that a collection is partially
+       installed (i.e., only some of its packages are installed.)"""
+
+    # /////////////////////////////////////////////////////////////////
+    # Constructor
+    # /////////////////////////////////////////////////////////////////
+
+    def __init__(self, server_index_url=None, download_dir=None):
+        self._url = server_index_url or self.DEFAULT_URL
+        """The URL for the data server's index file."""
+
+        self._collections = {}
+        """Dictionary from collection identifier to ``Collection``"""
+
+        self._packages = {}
+        """Dictionary from package identifier to ``Package``"""
+
+        self._download_dir = download_dir
+        """The default directory to which packages will be downloaded."""
+
+        self._index = None
+        """The XML index file downloaded from the data server"""
+
+        self._index_timestamp = None
+        """Time at which ``self._index`` was downloaded.  If it is more
+           than ``INDEX_TIMEOUT`` seconds old, it will be re-downloaded."""
+
+        self._status_cache = {}
+        """Dictionary from package/collection identifier to status
+           string (``INSTALLED``, ``NOT_INSTALLED``, ``STALE``, or
+           ``PARTIAL``).  Cache is used for packages only, not
+           collections."""
+
+        self._errors = None
+        """Flag for telling if all packages got successfully downloaded or not."""
+
+        # decide where we're going to save things to.
+        if self._download_dir is None:
+            self._download_dir = self.default_download_dir()
+
+    # /////////////////////////////////////////////////////////////////
+    # Information
+    # /////////////////////////////////////////////////////////////////
+
+    def list(
+        self,
+        download_dir=None,
+        show_packages=True,
+        show_collections=True,
+        header=True,
+        more_prompt=False,
+        skip_installed=False,
+    ):
+        lines = 0  # for more_prompt
+        if download_dir is None:
+            download_dir = self._download_dir
+            print("Using default data directory (%s)" % download_dir)
+        if header:
+            print("=" * (26 + len(self._url)))
+            print(" Data server index for <%s>" % self._url)
+            print("=" * (26 + len(self._url)))
+            lines += 3  # for more_prompt
+        stale = partial = False
+
+        categories = []
+        if show_packages:
+            categories.append("packages")
+        if show_collections:
+            categories.append("collections")
+        for category in categories:
+            print("%s:" % category.capitalize())
+            lines += 1  # for more_prompt
+            for info in sorted(getattr(self, category)(), key=str):
+                status = self.status(info, download_dir)
+                if status == self.INSTALLED and skip_installed:
+                    continue
+                if status == self.STALE:
+                    stale = True
+                if status == self.PARTIAL:
+                    partial = True
+                prefix = {
+                    self.INSTALLED: "*",
+                    self.STALE: "-",
+                    self.PARTIAL: "P",
+                    self.NOT_INSTALLED: " ",
+                }[status]
+                name = textwrap.fill(
+                    "-" * 27 + (info.name or info.id), 75, subsequent_indent=27 * " "
+                )[27:]
+                print("  [{}] {} {}".format(prefix, info.id.ljust(20, "."), name))
+                lines += len(name.split("\n"))  # for more_prompt
+                if more_prompt and lines > 20:
+                    user_input = input("Hit Enter to continue: ")
+                    if user_input.lower() in ("x", "q"):
+                        return
+                    lines = 0
+            print()
+        msg = "([*] marks installed packages"
+        if stale:
+            msg += "; [-] marks out-of-date or corrupt packages"
+        if partial:
+            msg += "; [P] marks partially installed collections"
+        print(textwrap.fill(msg + ")", subsequent_indent=" ", width=76))
+
+    def packages(self):
+        self._update_index()
+        return self._packages.values()
+
+    def corpora(self):
+        self._update_index()
+        return [pkg for (id, pkg) in self._packages.items() if pkg.subdir == "corpora"]
+
+    def models(self):
+        self._update_index()
+        return [pkg for (id, pkg) in self._packages.items() if pkg.subdir != "corpora"]
+
+    def collections(self):
+        self._update_index()
+        return self._collections.values()
+
+    # /////////////////////////////////////////////////////////////////
+    # Downloading
+    # /////////////////////////////////////////////////////////////////
+
+    def _info_or_id(self, info_or_id):
+        if isinstance(info_or_id, str):
+            return self.info(info_or_id)
+        else:
+            return info_or_id
+
+    # [xx] When during downloading is it 'safe' to abort?  Only unsafe
+    # time is *during* an unzip -- we don't want to leave a
+    # partially-unzipped corpus in place because we wouldn't notice
+    # it.  But if we had the exact total size of the unzipped corpus,
+    # then that would be fine.  Then we could abort anytime we want!
+    # So this is really what we should do.  That way the threaded
+    # downloader in the gui can just kill the download thread anytime
+    # it wants.
+
+    def incr_download(self, info_or_id, download_dir=None, force=False):
+        # If they didn't specify a download_dir, then use the default one.
+        if download_dir is None:
+            download_dir = self._download_dir
+            yield SelectDownloadDirMessage(download_dir)
+
+        # If they gave us a list of ids, then download each one.
+        if isinstance(info_or_id, (list, tuple)):
+            yield from self._download_list(info_or_id, download_dir, force)
+            return
+
+        # Look up the requested collection or package.
+        try:
+            info = self._info_or_id(info_or_id)
+        except (OSError, ValueError) as e:
+            yield ErrorMessage(None, f"Error loading {info_or_id}: {e}")
+            return
+
+        # Handle collections.
+        if isinstance(info, Collection):
+            yield StartCollectionMessage(info)
+            yield from self.incr_download(info.children, download_dir, force)
+            yield FinishCollectionMessage(info)
+
+        # Handle Packages (delegate to a helper function).
+        else:
+            yield from self._download_package(info, download_dir, force)
+
+    def _num_packages(self, item):
+        if isinstance(item, Package):
+            return 1
+        else:
+            return len(item.packages)
+
+    def _download_list(self, items, download_dir, force):
+        # Look up the requested items.
+        for i in range(len(items)):
+            try:
+                items[i] = self._info_or_id(items[i])
+            except (OSError, ValueError) as e:
+                yield ErrorMessage(items[i], e)
+                return
+
+        # Download each item, re-scaling their progress.
+        num_packages = sum(self._num_packages(item) for item in items)
+        progress = 0
+        for i, item in enumerate(items):
+            if isinstance(item, Package):
+                delta = 1.0 / num_packages
+            else:
+                delta = len(item.packages) / num_packages
+            for msg in self.incr_download(item, download_dir, force):
+                if isinstance(msg, ProgressMessage):
+                    yield ProgressMessage(progress + msg.progress * delta)
+                else:
+                    yield msg
+
+            progress += 100 * delta
+
+    def _download_package(self, info, download_dir, force):
+        yield StartPackageMessage(info)
+        yield ProgressMessage(0)
+
+        # Do we already have the current version?
+        status = self.status(info, download_dir)
+        if not force and status == self.INSTALLED:
+            yield UpToDateMessage(info)
+            yield ProgressMessage(100)
+            yield FinishPackageMessage(info)
+            return
+
+        # Remove the package from our status cache
+        self._status_cache.pop(info.id, None)
+
+        # Check for (and remove) any old/stale version.
+        filepath = os.path.join(download_dir, info.filename)
+        if os.path.exists(filepath):
+            if status == self.STALE:
+                yield StaleMessage(info)
+            os.remove(filepath)
+
+        # Ensure the download_dir exists
+        if not os.path.exists(download_dir):
+            os.makedirs(download_dir)
+        if not os.path.exists(os.path.join(download_dir, info.subdir)):
+            os.makedirs(os.path.join(download_dir, info.subdir))
+
+        # Download the file.  This will raise an IOError if the url
+        # is not found.
+        yield StartDownloadMessage(info)
+        yield ProgressMessage(5)
+        try:
+            infile = urlopen(info.url)
+            with open(filepath, "wb") as outfile:
+                num_blocks = max(1, info.size / (1024 * 16))
+                for block in itertools.count():
+                    s = infile.read(1024 * 16)  # 16k blocks.
+                    outfile.write(s)
+                    if not s:
+                        break
+                    if block % 2 == 0:  # how often?
+                        yield ProgressMessage(min(80, 5 + 75 * (block / num_blocks)))
+            infile.close()
+        except OSError as e:
+            yield ErrorMessage(
+                info,
+                "Error downloading %r from <%s>:" "\n  %s" % (info.id, info.url, e),
+            )
+            return
+        yield FinishDownloadMessage(info)
+        yield ProgressMessage(80)
+
+        # If it's a zipfile, uncompress it.
+        if info.filename.endswith(".zip"):
+            zipdir = os.path.join(download_dir, info.subdir)
+            # Unzip if we're unzipping by default; *or* if it's already
+            # been unzipped (presumably a previous version).
+            if info.unzip or os.path.exists(os.path.join(zipdir, info.id)):
+                yield StartUnzipMessage(info)
+                for msg in _unzip_iter(filepath, zipdir, verbose=False):
+                    # Somewhat of a hack, but we need a proper package reference
+                    msg.package = info
+                    yield msg
+                yield FinishUnzipMessage(info)
+
+        yield FinishPackageMessage(info)
+
+    def download(
+        self,
+        info_or_id=None,
+        download_dir=None,
+        quiet=False,
+        force=False,
+        prefix="[nltk_data] ",
+        halt_on_error=True,
+        raise_on_error=False,
+        print_error_to=sys.stderr,
+    ):
+
+        print_to = functools.partial(print, file=print_error_to)
+        # If no info or id is given, then use the interactive shell.
+        if info_or_id is None:
+            # [xx] hmm -- changing self._download_dir here seems like
+            # the wrong thing to do.  Maybe the _interactive_download
+            # function should make a new copy of self to use?
+            if download_dir is not None:
+                self._download_dir = download_dir
+            self._interactive_download()
+            return True
+
+        else:
+            # Define a helper function for displaying output:
+            def show(s, prefix2=""):
+                print_to(
+                    textwrap.fill(
+                        s,
+                        initial_indent=prefix + prefix2,
+                        subsequent_indent=prefix + prefix2 + " " * 4,
+                    )
+                )
+
+            for msg in self.incr_download(info_or_id, download_dir, force):
+                # Error messages
+                if isinstance(msg, ErrorMessage):
+                    show(msg.message)
+                    if raise_on_error:
+                        raise ValueError(msg.message)
+                    if halt_on_error:
+                        return False
+                    self._errors = True
+                    if not quiet:
+                        print_to("Error installing package. Retry? [n/y/e]")
+                        choice = input().strip()
+                        if choice in ["y", "Y"]:
+                            if not self.download(
+                                msg.package.id,
+                                download_dir,
+                                quiet,
+                                force,
+                                prefix,
+                                halt_on_error,
+                                raise_on_error,
+                            ):
+                                return False
+                        elif choice in ["e", "E"]:
+                            return False
+
+                # All other messages
+                if not quiet:
+                    # Collection downloading messages:
+                    if isinstance(msg, StartCollectionMessage):
+                        show("Downloading collection %r" % msg.collection.id)
+                        prefix += "   | "
+                        print_to(prefix)
+                    elif isinstance(msg, FinishCollectionMessage):
+                        print_to(prefix)
+                        prefix = prefix[:-4]
+                        if self._errors:
+                            show(
+                                "Downloaded collection %r with errors"
+                                % msg.collection.id
+                            )
+                        else:
+                            show("Done downloading collection %s" % msg.collection.id)
+
+                    # Package downloading messages:
+                    elif isinstance(msg, StartPackageMessage):
+                        show(
+                            "Downloading package %s to %s..."
+                            % (msg.package.id, download_dir)
+                        )
+                    elif isinstance(msg, UpToDateMessage):
+                        show("Package %s is already up-to-date!" % msg.package.id, "  ")
+                    # elif isinstance(msg, StaleMessage):
+                    #    show('Package %s is out-of-date or corrupt' %
+                    #         msg.package.id, '  ')
+                    elif isinstance(msg, StartUnzipMessage):
+                        show("Unzipping %s." % msg.package.filename, "  ")
+
+                    # Data directory message:
+                    elif isinstance(msg, SelectDownloadDirMessage):
+                        download_dir = msg.download_dir
+        return True
+
+    def is_stale(self, info_or_id, download_dir=None):
+        return self.status(info_or_id, download_dir) == self.STALE
+
+    def is_installed(self, info_or_id, download_dir=None):
+        return self.status(info_or_id, download_dir) == self.INSTALLED
+
+    def clear_status_cache(self, id=None):
+        if id is None:
+            self._status_cache.clear()
+        else:
+            self._status_cache.pop(id, None)
+
+    def status(self, info_or_id, download_dir=None):
+        """
+        Return a constant describing the status of the given package
+        or collection.  Status can be one of ``INSTALLED``,
+        ``NOT_INSTALLED``, ``STALE``, or ``PARTIAL``.
+        """
+        if download_dir is None:
+            download_dir = self._download_dir
+        info = self._info_or_id(info_or_id)
+
+        # Handle collections:
+        if isinstance(info, Collection):
+            pkg_status = [self.status(pkg.id) for pkg in info.packages]
+            if self.STALE in pkg_status:
+                return self.STALE
+            elif self.PARTIAL in pkg_status:
+                return self.PARTIAL
+            elif self.INSTALLED in pkg_status and self.NOT_INSTALLED in pkg_status:
+                return self.PARTIAL
+            elif self.NOT_INSTALLED in pkg_status:
+                return self.NOT_INSTALLED
+            else:
+                return self.INSTALLED
+
+        # Handle packages:
+        else:
+            filepath = os.path.join(download_dir, info.filename)
+            if download_dir != self._download_dir:
+                return self._pkg_status(info, filepath)
+            else:
+                if info.id not in self._status_cache:
+                    self._status_cache[info.id] = self._pkg_status(info, filepath)
+                return self._status_cache[info.id]
+
+    def _pkg_status(self, info, filepath):
+        if not os.path.exists(filepath):
+            return self.NOT_INSTALLED
+
+        # Check if the file has the correct size.
+        try:
+            filestat = os.stat(filepath)
+        except OSError:
+            return self.NOT_INSTALLED
+        if filestat.st_size != int(info.size):
+            return self.STALE
+
+        # Check if the file's checksum matches
+        if md5_hexdigest(filepath) != info.checksum:
+            return self.STALE
+
+        # If it's a zipfile, and it's been at least partially
+        # unzipped, then check if it's been fully unzipped.
+        if filepath.endswith(".zip"):
+            unzipdir = filepath[:-4]
+            if not os.path.exists(unzipdir):
+                return self.INSTALLED  # but not unzipped -- ok!
+            if not os.path.isdir(unzipdir):
+                return self.STALE
+
+            unzipped_size = sum(
+                os.stat(os.path.join(d, f)).st_size
+                for d, _, files in os.walk(unzipdir)
+                for f in files
+            )
+            if unzipped_size != info.unzipped_size:
+                return self.STALE
+
+        # Otherwise, everything looks good.
+        return self.INSTALLED
+
+    def update(self, quiet=False, prefix="[nltk_data] "):
+        """
+        Re-download any packages whose status is STALE.
+        """
+        self.clear_status_cache()
+        for pkg in self.packages():
+            if self.status(pkg) == self.STALE:
+                self.download(pkg, quiet=quiet, prefix=prefix)
+
+    # /////////////////////////////////////////////////////////////////
+    # Index
+    # /////////////////////////////////////////////////////////////////
+
+    def _update_index(self, url=None):
+        """A helper function that ensures that self._index is
+        up-to-date.  If the index is older than self.INDEX_TIMEOUT,
+        then download it again."""
+        # Check if the index is already up-to-date.  If so, do nothing.
+        if not (
+            self._index is None
+            or url is not None
+            or time.time() - self._index_timestamp > self.INDEX_TIMEOUT
+        ):
+            return
+
+        # If a URL was specified, then update our URL.
+        self._url = url or self._url
+
+        # Download the index file.
+        self._index = nltk.internals.ElementWrapper(
+            ElementTree.parse(urlopen(self._url)).getroot()
+        )
+        self._index_timestamp = time.time()
+
+        # Build a dictionary of packages.
+        packages = [Package.fromxml(p) for p in self._index.findall("packages/package")]
+        self._packages = {p.id: p for p in packages}
+
+        # Build a dictionary of collections.
+        collections = [
+            Collection.fromxml(c) for c in self._index.findall("collections/collection")
+        ]
+        self._collections = {c.id: c for c in collections}
+
+        # Replace identifiers with actual children in collection.children.
+        for collection in self._collections.values():
+            for i, child_id in enumerate(collection.children):
+                if child_id in self._packages:
+                    collection.children[i] = self._packages[child_id]
+                elif child_id in self._collections:
+                    collection.children[i] = self._collections[child_id]
+                else:
+                    print(
+                        "removing collection member with no package: {}".format(
+                            child_id
+                        )
+                    )
+                    del collection.children[i]
+
+        # Fill in collection.packages for each collection.
+        for collection in self._collections.values():
+            packages = {}
+            queue = [collection]
+            for child in queue:
+                if isinstance(child, Collection):
+                    queue.extend(child.children)
+                elif isinstance(child, Package):
+                    packages[child.id] = child
+                else:
+                    pass
+            collection.packages = packages.values()
+
+        # Flush the status cache
+        self._status_cache.clear()
+
+    def index(self):
+        """
+        Return the XML index describing the packages available from
+        the data server.  If necessary, this index will be downloaded
+        from the data server.
+        """
+        self._update_index()
+        return self._index
+
+    def info(self, id):
+        """Return the ``Package`` or ``Collection`` record for the
+        given item."""
+        self._update_index()
+        if id in self._packages:
+            return self._packages[id]
+        if id in self._collections:
+            return self._collections[id]
+        raise ValueError("Package %r not found in index" % id)
+
+    def xmlinfo(self, id):
+        """Return the XML info record for the given item"""
+        self._update_index()
+        for package in self._index.findall("packages/package"):
+            if package.get("id") == id:
+                return package
+        for collection in self._index.findall("collections/collection"):
+            if collection.get("id") == id:
+                return collection
+        raise ValueError("Package %r not found in index" % id)
+
+    # /////////////////////////////////////////////////////////////////
+    # URL & Data Directory
+    # /////////////////////////////////////////////////////////////////
+
+    def _get_url(self):
+        """The URL for the data server's index file."""
+        return self._url
+
+    def _set_url(self, url):
+        """
+        Set a new URL for the data server. If we're unable to contact
+        the given url, then the original url is kept.
+        """
+        original_url = self._url
+        try:
+            self._update_index(url)
+        except:
+            self._url = original_url
+            raise
+
+    url = property(_get_url, _set_url)
+
+    def default_download_dir(self):
+        """
+        Return the directory to which packages will be downloaded by
+        default.  This value can be overridden using the constructor,
+        or on a case-by-case basis using the ``download_dir`` argument when
+        calling ``download()``.
+
+        On Windows, the default download directory is
+        ``PYTHONHOME/lib/nltk``, where *PYTHONHOME* is the
+        directory containing Python, e.g. ``C:\\Python25``.
+
+        On all other platforms, the default directory is the first of
+        the following which exists or which can be created with write
+        permission: ``/usr/share/nltk_data``, ``/usr/local/share/nltk_data``,
+        ``/usr/lib/nltk_data``, ``/usr/local/lib/nltk_data``, ``~/nltk_data``.
+        """
+        # Check if we are on GAE where we cannot write into filesystem.
+        if "APPENGINE_RUNTIME" in os.environ:
+            return
+
+        # Check if we have sufficient permissions to install in a
+        # variety of system-wide locations.
+        for nltkdir in nltk.data.path:
+            if os.path.exists(nltkdir) and nltk.internals.is_writable(nltkdir):
+                return nltkdir
+
+        # On Windows, use %APPDATA%
+        if sys.platform == "win32" and "APPDATA" in os.environ:
+            homedir = os.environ["APPDATA"]
+
+        # Otherwise, install in the user's home directory.
+        else:
+            homedir = os.path.expanduser("~/")
+            if homedir == "~/":
+                raise ValueError("Could not find a default download directory")
+
+        # append "nltk_data" to the home directory
+        return os.path.join(homedir, "nltk_data")
+
+    def _get_download_dir(self):
+        """
+        The default directory to which packages will be downloaded.
+        This defaults to the value returned by ``default_download_dir()``.
+        To override this default on a case-by-case basis, use the
+        ``download_dir`` argument when calling ``download()``.
+        """
+        return self._download_dir
+
+    def _set_download_dir(self, download_dir):
+        self._download_dir = download_dir
+        # Clear the status cache.
+        self._status_cache.clear()
+
+    download_dir = property(_get_download_dir, _set_download_dir)
+
+    # /////////////////////////////////////////////////////////////////
+    # Interactive Shell
+    # /////////////////////////////////////////////////////////////////
+
+    def _interactive_download(self):
+        # Try the GUI first; if that doesn't work, try the simple
+        # interactive shell.
+        if TKINTER:
+            try:
+                DownloaderGUI(self).mainloop()
+            except TclError:
+                DownloaderShell(self).run()
+        else:
+            DownloaderShell(self).run()
+
+
+class DownloaderShell:
+    def __init__(self, dataserver):
+        self._ds = dataserver
+
+    def _simple_interactive_menu(self, *options):
+        print("-" * 75)
+        spc = (68 - sum(len(o) for o in options)) // (len(options) - 1) * " "
+        print("    " + spc.join(options))
+        print("-" * 75)
+
+    def run(self):
+        print("NLTK Downloader")
+        while True:
+            self._simple_interactive_menu(
+                "d) Download",
+                "l) List",
+                " u) Update",
+                "c) Config",
+                "h) Help",
+                "q) Quit",
+            )
+            user_input = input("Downloader> ").strip()
+            if not user_input:
+                print()
+                continue
+            command = user_input.lower().split()[0]
+            args = user_input.split()[1:]
+            try:
+                if command == "l":
+                    print()
+                    self._ds.list(self._ds.download_dir, header=False, more_prompt=True)
+                elif command == "h":
+                    self._simple_interactive_help()
+                elif command == "c":
+                    self._simple_interactive_config()
+                elif command in ("q", "x"):
+                    return
+                elif command == "d":
+                    self._simple_interactive_download(args)
+                elif command == "u":
+                    self._simple_interactive_update()
+                else:
+                    print("Command %r unrecognized" % user_input)
+            except HTTPError as e:
+                print("Error reading from server: %s" % e)
+            except URLError as e:
+                print("Error connecting to server: %s" % e.reason)
+            # try checking if user_input is a package name, &
+            # downloading it?
+            print()
+
+    def _simple_interactive_download(self, args):
+        if args:
+            for arg in args:
+                try:
+                    self._ds.download(arg, prefix="    ")
+                except (OSError, ValueError) as e:
+                    print(e)
+        else:
+            while True:
+                print()
+                print("Download which package (l=list; x=cancel)?")
+                user_input = input("  Identifier> ")
+                if user_input.lower() == "l":
+                    self._ds.list(
+                        self._ds.download_dir,
+                        header=False,
+                        more_prompt=True,
+                        skip_installed=True,
+                    )
+                    continue
+                elif user_input.lower() in ("x", "q", ""):
+                    return
+                elif user_input:
+                    for id in user_input.split():
+                        try:
+                            self._ds.download(id, prefix="    ")
+                        except (OSError, ValueError) as e:
+                            print(e)
+                    break
+
+    def _simple_interactive_update(self):
+        while True:
+            stale_packages = []
+            stale = partial = False
+            for info in sorted(getattr(self._ds, "packages")(), key=str):
+                if self._ds.status(info) == self._ds.STALE:
+                    stale_packages.append((info.id, info.name))
+
+            print()
+            if stale_packages:
+                print("Will update following packages (o=ok; x=cancel)")
+                for pid, pname in stale_packages:
+                    name = textwrap.fill(
+                        "-" * 27 + (pname), 75, subsequent_indent=27 * " "
+                    )[27:]
+                    print("  [ ] {} {}".format(pid.ljust(20, "."), name))
+                print()
+
+                user_input = input("  Identifier> ")
+                if user_input.lower() == "o":
+                    for pid, pname in stale_packages:
+                        try:
+                            self._ds.download(pid, prefix="    ")
+                        except (OSError, ValueError) as e:
+                            print(e)
+                    break
+                elif user_input.lower() in ("x", "q", ""):
+                    return
+            else:
+                print("Nothing to update.")
+                return
+
+    def _simple_interactive_help(self):
+        print()
+        print("Commands:")
+        print(
+            "  d) Download a package or collection     u) Update out of date packages"
+        )
+        print("  l) List packages & collections          h) Help")
+        print("  c) View & Modify Configuration          q) Quit")
+
+    def _show_config(self):
+        print()
+        print("Data Server:")
+        print("  - URL: <%s>" % self._ds.url)
+        print("  - %d Package Collections Available" % len(self._ds.collections()))
+        print("  - %d Individual Packages Available" % len(self._ds.packages()))
+        print()
+        print("Local Machine:")
+        print("  - Data directory: %s" % self._ds.download_dir)
+
+    def _simple_interactive_config(self):
+        self._show_config()
+        while True:
+            print()
+            self._simple_interactive_menu(
+                "s) Show Config", "u) Set Server URL", "d) Set Data Dir", "m) Main Menu"
+            )
+            user_input = input("Config> ").strip().lower()
+            if user_input == "s":
+                self._show_config()
+            elif user_input == "d":
+                new_dl_dir = input("  New Directory> ").strip()
+                if new_dl_dir in ("", "x", "q", "X", "Q"):
+                    print("  Cancelled!")
+                elif os.path.isdir(new_dl_dir):
+                    self._ds.download_dir = new_dl_dir
+                else:
+                    print("Directory %r not found!  Create it first." % new_dl_dir)
+            elif user_input == "u":
+                new_url = input("  New URL> ").strip()
+                if new_url in ("", "x", "q", "X", "Q"):
+                    print("  Cancelled!")
+                else:
+                    if not new_url.startswith(("http://", "https://")):
+                        new_url = "http://" + new_url
+                    try:
+                        self._ds.url = new_url
+                    except Exception as e:
+                        print(f"Error reading <{new_url!r}>:\n  {e}")
+            elif user_input == "m":
+                break
+
+
+class DownloaderGUI:
+    """
+    Graphical interface for downloading packages from the NLTK data
+    server.
+    """
+
+    # /////////////////////////////////////////////////////////////////
+    # Column Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    COLUMNS = [
+        "",
+        "Identifier",
+        "Name",
+        "Size",
+        "Status",
+        "Unzipped Size",
+        "Copyright",
+        "Contact",
+        "License",
+        "Author",
+        "Subdir",
+        "Checksum",
+    ]
+    """A list of the names of columns.  This controls the order in
+       which the columns will appear.  If this is edited, then
+       ``_package_to_columns()`` may need to be edited to match."""
+
+    COLUMN_WEIGHTS = {"": 0, "Name": 5, "Size": 0, "Status": 0}
+    """A dictionary specifying how columns should be resized when the
+       table is resized.  Columns with weight 0 will not be resized at
+       all; and columns with high weight will be resized more.
+       Default weight (for columns not explicitly listed) is 1."""
+
+    COLUMN_WIDTHS = {
+        "": 1,
+        "Identifier": 20,
+        "Name": 45,
+        "Size": 10,
+        "Unzipped Size": 10,
+        "Status": 12,
+    }
+    """A dictionary specifying how wide each column should be, in
+       characters.  The default width (for columns not explicitly
+       listed) is specified by ``DEFAULT_COLUMN_WIDTH``."""
+
+    DEFAULT_COLUMN_WIDTH = 30
+    """The default width for columns that are not explicitly listed
+       in ``COLUMN_WIDTHS``."""
+
+    INITIAL_COLUMNS = ["", "Identifier", "Name", "Size", "Status"]
+    """The set of columns that should be displayed by default."""
+
+    # Perform a few import-time sanity checks to make sure that the
+    # column configuration variables are defined consistently:
+    for c in COLUMN_WEIGHTS:
+        assert c in COLUMNS
+    for c in COLUMN_WIDTHS:
+        assert c in COLUMNS
+    for c in INITIAL_COLUMNS:
+        assert c in COLUMNS
+
+    # /////////////////////////////////////////////////////////////////
+    # Color Configuration
+    # /////////////////////////////////////////////////////////////////
+
+    _BACKDROP_COLOR = ("#000", "#ccc")
+
+    _ROW_COLOR = {
+        Downloader.INSTALLED: ("#afa", "#080"),
+        Downloader.PARTIAL: ("#ffa", "#880"),
+        Downloader.STALE: ("#faa", "#800"),
+        Downloader.NOT_INSTALLED: ("#fff", "#888"),
+    }
+
+    _MARK_COLOR = ("#000", "#ccc")
+
+    # _FRONT_TAB_COLOR = ('#ccf', '#008')
+    # _BACK_TAB_COLOR = ('#88a', '#448')
+    _FRONT_TAB_COLOR = ("#fff", "#45c")
+    _BACK_TAB_COLOR = ("#aaa", "#67a")
+
+    _PROGRESS_COLOR = ("#f00", "#aaa")
+
+    _TAB_FONT = "helvetica -16 bold"
+
+    # /////////////////////////////////////////////////////////////////
+    # Constructor
+    # /////////////////////////////////////////////////////////////////
+
+    def __init__(self, dataserver, use_threads=True):
+        self._ds = dataserver
+        self._use_threads = use_threads
+
+        # For the threaded downloader:
+        self._download_lock = threading.Lock()
+        self._download_msg_queue = []
+        self._download_abort_queue = []
+        self._downloading = False
+
+        # For tkinter after callbacks:
+        self._afterid = {}
+
+        # A message log.
+        self._log_messages = []
+        self._log_indent = 0
+        self._log("NLTK Downloader Started!")
+
+        # Create the main window.
+        top = self.top = Tk()
+        top.geometry("+50+50")
+        top.title("NLTK Downloader")
+        top.configure(background=self._BACKDROP_COLOR[1])
+
+        # Set up some bindings now, in case anything goes wrong.
+        top.bind("<Control-q>", self.destroy)
+        top.bind("<Control-x>", self.destroy)
+        self._destroyed = False
+
+        self._column_vars = {}
+
+        # Initialize the GUI.
+        self._init_widgets()
+        self._init_menu()
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+
+        self._show_info()
+        self._select_columns()
+        self._table.select(0)
+
+        # Make sure we get notified when we're destroyed, so we can
+        # cancel any download in progress.
+        self._table.bind("<Destroy>", self._destroy)
+
+    def _log(self, msg):
+        self._log_messages.append(
+            "{} {}{}".format(time.ctime(), " | " * self._log_indent, msg)
+        )
+
+    # /////////////////////////////////////////////////////////////////
+    # Internals
+    # /////////////////////////////////////////////////////////////////
+
+    def _init_widgets(self):
+        # Create the top-level frame structures
+        f1 = Frame(self.top, relief="raised", border=2, padx=8, pady=0)
+        f1.pack(sid="top", expand=True, fill="both")
+        f1.grid_rowconfigure(2, weight=1)
+        f1.grid_columnconfigure(0, weight=1)
+        Frame(f1, height=8).grid(column=0, row=0)  # spacer
+        tabframe = Frame(f1)
+        tabframe.grid(column=0, row=1, sticky="news")
+        tableframe = Frame(f1)
+        tableframe.grid(column=0, row=2, sticky="news")
+        buttonframe = Frame(f1)
+        buttonframe.grid(column=0, row=3, sticky="news")
+        Frame(f1, height=8).grid(column=0, row=4)  # spacer
+        infoframe = Frame(f1)
+        infoframe.grid(column=0, row=5, sticky="news")
+        Frame(f1, height=8).grid(column=0, row=6)  # spacer
+        progressframe = Frame(
+            self.top, padx=3, pady=3, background=self._BACKDROP_COLOR[1]
+        )
+        progressframe.pack(side="bottom", fill="x")
+        self.top["border"] = 0
+        self.top["highlightthickness"] = 0
+
+        # Create the tabs
+        self._tab_names = ["Collections", "Corpora", "Models", "All Packages"]
+        self._tabs = {}
+        for i, tab in enumerate(self._tab_names):
+            label = Label(tabframe, text=tab, font=self._TAB_FONT)
+            label.pack(side="left", padx=((i + 1) % 2) * 10)
+            label.bind("<Button-1>", self._select_tab)
+            self._tabs[tab.lower()] = label
+
+        # Create the table.
+        column_weights = [self.COLUMN_WEIGHTS.get(column, 1) for column in self.COLUMNS]
+        self._table = Table(
+            tableframe,
+            self.COLUMNS,
+            column_weights=column_weights,
+            highlightthickness=0,
+            listbox_height=16,
+            reprfunc=self._table_reprfunc,
+        )
+        self._table.columnconfig(0, foreground=self._MARK_COLOR[0])  # marked
+        for i, column in enumerate(self.COLUMNS):
+            width = self.COLUMN_WIDTHS.get(column, self.DEFAULT_COLUMN_WIDTH)
+            self._table.columnconfig(i, width=width)
+        self._table.pack(expand=True, fill="both")
+        self._table.focus()
+        self._table.bind_to_listboxes("<Double-Button-1>", self._download)
+        self._table.bind("<space>", self._table_mark)
+        self._table.bind("<Return>", self._download)
+        self._table.bind("<Left>", self._prev_tab)
+        self._table.bind("<Right>", self._next_tab)
+        self._table.bind("<Control-a>", self._mark_all)
+
+        # Create entry boxes for URL & download_dir
+        infoframe.grid_columnconfigure(1, weight=1)
+
+        info = [
+            ("url", "Server Index:", self._set_url),
+            ("download_dir", "Download Directory:", self._set_download_dir),
+        ]
+        self._info = {}
+        for (i, (key, label, callback)) in enumerate(info):
+            Label(infoframe, text=label).grid(column=0, row=i, sticky="e")
+            entry = Entry(
+                infoframe,
+                font="courier",
+                relief="groove",
+                disabledforeground="#007aff",
+                foreground="#007aff",
+            )
+            self._info[key] = (entry, callback)
+            entry.bind("<Return>", self._info_save)
+            entry.bind("<Button-1>", lambda e, key=key: self._info_edit(key))
+            entry.grid(column=1, row=i, sticky="ew")
+
+        # If the user edits url or download_dir, and then clicks outside
+        # the entry box, then save their results.
+        self.top.bind("<Button-1>", self._info_save)
+
+        # Create Download & Refresh buttons.
+        self._download_button = Button(
+            buttonframe, text="Download", command=self._download, width=8
+        )
+        self._download_button.pack(side="left")
+        self._refresh_button = Button(
+            buttonframe, text="Refresh", command=self._refresh, width=8
+        )
+        self._refresh_button.pack(side="right")
+
+        # Create Progress bar
+        self._progresslabel = Label(
+            progressframe,
+            text="",
+            foreground=self._BACKDROP_COLOR[0],
+            background=self._BACKDROP_COLOR[1],
+        )
+        self._progressbar = Canvas(
+            progressframe,
+            width=200,
+            height=16,
+            background=self._PROGRESS_COLOR[1],
+            relief="sunken",
+            border=1,
+        )
+        self._init_progressbar()
+        self._progressbar.pack(side="right")
+        self._progresslabel.pack(side="left")
+
+    def _init_menu(self):
+        menubar = Menu(self.top)
+
+        filemenu = Menu(menubar, tearoff=0)
+        filemenu.add_command(
+            label="Download", underline=0, command=self._download, accelerator="Return"
+        )
+        filemenu.add_separator()
+        filemenu.add_command(
+            label="Change Server Index",
+            underline=7,
+            command=lambda: self._info_edit("url"),
+        )
+        filemenu.add_command(
+            label="Change Download Directory",
+            underline=0,
+            command=lambda: self._info_edit("download_dir"),
+        )
+        filemenu.add_separator()
+        filemenu.add_command(label="Show Log", underline=5, command=self._show_log)
+        filemenu.add_separator()
+        filemenu.add_command(
+            label="Exit", underline=1, command=self.destroy, accelerator="Ctrl-x"
+        )
+        menubar.add_cascade(label="File", underline=0, menu=filemenu)
+
+        # Create a menu to control which columns of the table are
+        # shown.  n.b.: we never hide the first two columns (mark and
+        # identifier).
+        viewmenu = Menu(menubar, tearoff=0)
+        for column in self._table.column_names[2:]:
+            var = IntVar(self.top)
+            assert column not in self._column_vars
+            self._column_vars[column] = var
+            if column in self.INITIAL_COLUMNS:
+                var.set(1)
+            viewmenu.add_checkbutton(
+                label=column, underline=0, variable=var, command=self._select_columns
+            )
+        menubar.add_cascade(label="View", underline=0, menu=viewmenu)
+
+        # Create a sort menu
+        # [xx] this should be selectbuttons; and it should include
+        # reversed sorts as options.
+        sortmenu = Menu(menubar, tearoff=0)
+        for column in self._table.column_names[1:]:
+            sortmenu.add_command(
+                label="Sort by %s" % column,
+                command=(lambda c=column: self._table.sort_by(c, "ascending")),
+            )
+        sortmenu.add_separator()
+        # sortmenu.add_command(label='Descending Sort:')
+        for column in self._table.column_names[1:]:
+            sortmenu.add_command(
+                label="Reverse sort by %s" % column,
+                command=(lambda c=column: self._table.sort_by(c, "descending")),
+            )
+        menubar.add_cascade(label="Sort", underline=0, menu=sortmenu)
+
+        helpmenu = Menu(menubar, tearoff=0)
+        helpmenu.add_command(label="About", underline=0, command=self.about)
+        helpmenu.add_command(
+            label="Instructions", underline=0, command=self.help, accelerator="F1"
+        )
+        menubar.add_cascade(label="Help", underline=0, menu=helpmenu)
+        self.top.bind("<F1>", self.help)
+
+        self.top.config(menu=menubar)
+
+    def _select_columns(self):
+        for (column, var) in self._column_vars.items():
+            if var.get():
+                self._table.show_column(column)
+            else:
+                self._table.hide_column(column)
+
+    def _refresh(self):
+        self._ds.clear_status_cache()
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+        self._table.select(0)
+
+    def _info_edit(self, info_key):
+        self._info_save()  # just in case.
+        (entry, callback) = self._info[info_key]
+        entry["state"] = "normal"
+        entry["relief"] = "sunken"
+        entry.focus()
+
+    def _info_save(self, e=None):
+        focus = self._table
+        for entry, callback in self._info.values():
+            if entry["state"] == "disabled":
+                continue
+            if e is not None and e.widget is entry and e.keysym != "Return":
+                focus = entry
+            else:
+                entry["state"] = "disabled"
+                entry["relief"] = "groove"
+                callback(entry.get())
+        focus.focus()
+
+    def _table_reprfunc(self, row, col, val):
+        if self._table.column_names[col].endswith("Size"):
+            if isinstance(val, str):
+                return "  %s" % val
+            elif val < 1024**2:
+                return "  %.1f KB" % (val / 1024.0**1)
+            elif val < 1024**3:
+                return "  %.1f MB" % (val / 1024.0**2)
+            else:
+                return "  %.1f GB" % (val / 1024.0**3)
+
+        if col in (0, ""):
+            return str(val)
+        else:
+            return "  %s" % val
+
+    def _set_url(self, url):
+        if url == self._ds.url:
+            return
+        try:
+            self._ds.url = url
+            self._fill_table()
+        except OSError as e:
+            showerror("Error Setting Server Index", str(e))
+        self._show_info()
+
+    def _set_download_dir(self, download_dir):
+        if self._ds.download_dir == download_dir:
+            return
+        # check if the dir exists, and if not, ask if we should create it?
+
+        # Clear our status cache, & re-check what's installed
+        self._ds.download_dir = download_dir
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+        self._show_info()
+
+    def _show_info(self):
+        print("showing info", self._ds.url)
+        for entry, cb in self._info.values():
+            entry["state"] = "normal"
+            entry.delete(0, "end")
+        self._info["url"][0].insert(0, self._ds.url)
+        self._info["download_dir"][0].insert(0, self._ds.download_dir)
+        for entry, cb in self._info.values():
+            entry["state"] = "disabled"
+
+    def _prev_tab(self, *e):
+        for i, tab in enumerate(self._tab_names):
+            if tab.lower() == self._tab and i > 0:
+                self._tab = self._tab_names[i - 1].lower()
+                try:
+                    return self._fill_table()
+                except HTTPError as e:
+                    showerror("Error reading from server", e)
+                except URLError as e:
+                    showerror("Error connecting to server", e.reason)
+
+    def _next_tab(self, *e):
+        for i, tab in enumerate(self._tab_names):
+            if tab.lower() == self._tab and i < (len(self._tabs) - 1):
+                self._tab = self._tab_names[i + 1].lower()
+                try:
+                    return self._fill_table()
+                except HTTPError as e:
+                    showerror("Error reading from server", e)
+                except URLError as e:
+                    showerror("Error connecting to server", e.reason)
+
+    def _select_tab(self, event):
+        self._tab = event.widget["text"].lower()
+        try:
+            self._fill_table()
+        except HTTPError as e:
+            showerror("Error reading from server", e)
+        except URLError as e:
+            showerror("Error connecting to server", e.reason)
+
+    _tab = "collections"
+    # _tab = 'corpora'
+    _rows = None
+
+    def _fill_table(self):
+        selected_row = self._table.selected_row()
+        self._table.clear()
+        if self._tab == "all packages":
+            items = self._ds.packages()
+        elif self._tab == "corpora":
+            items = self._ds.corpora()
+        elif self._tab == "models":
+            items = self._ds.models()
+        elif self._tab == "collections":
+            items = self._ds.collections()
+        else:
+            assert 0, "bad tab value %r" % self._tab
+        rows = [self._package_to_columns(item) for item in items]
+        self._table.extend(rows)
+
+        # Highlight the active tab.
+        for tab, label in self._tabs.items():
+            if tab == self._tab:
+                label.configure(
+                    foreground=self._FRONT_TAB_COLOR[0],
+                    background=self._FRONT_TAB_COLOR[1],
+                )
+            else:
+                label.configure(
+                    foreground=self._BACK_TAB_COLOR[0],
+                    background=self._BACK_TAB_COLOR[1],
+                )
+
+        self._table.sort_by("Identifier", order="ascending")
+        self._color_table()
+        self._table.select(selected_row)
+
+        # This is a hack, because the scrollbar isn't updating its
+        # position right -- I'm not sure what the underlying cause is
+        # though.  (This is on OS X w/ python 2.5)  The length of
+        # delay that's necessary seems to depend on how fast the
+        # comptuer is. :-/
+        self.top.after(150, self._table._scrollbar.set, *self._table._mlb.yview())
+        self.top.after(300, self._table._scrollbar.set, *self._table._mlb.yview())
+
+    def _update_table_status(self):
+        for row_num in range(len(self._table)):
+            status = self._ds.status(self._table[row_num, "Identifier"])
+            self._table[row_num, "Status"] = status
+        self._color_table()
+
+    def _download(self, *e):
+        # If we're using threads, then delegate to the threaded
+        # downloader instead.
+        if self._use_threads:
+            return self._download_threaded(*e)
+
+        marked = [
+            self._table[row, "Identifier"]
+            for row in range(len(self._table))
+            if self._table[row, 0] != ""
+        ]
+        selection = self._table.selected_row()
+        if not marked and selection is not None:
+            marked = [self._table[selection, "Identifier"]]
+
+        download_iter = self._ds.incr_download(marked, self._ds.download_dir)
+        self._log_indent = 0
+        self._download_cb(download_iter, marked)
+
+    _DL_DELAY = 10
+
+    def _download_cb(self, download_iter, ids):
+        try:
+            msg = next(download_iter)
+        except StopIteration:
+            # self._fill_table(sort=False)
+            self._update_table_status()
+            afterid = self.top.after(10, self._show_progress, 0)
+            self._afterid["_download_cb"] = afterid
+            return
+
+        def show(s):
+            self._progresslabel["text"] = s
+            self._log(s)
+
+        if isinstance(msg, ProgressMessage):
+            self._show_progress(msg.progress)
+        elif isinstance(msg, ErrorMessage):
+            show(msg.message)
+            if msg.package is not None:
+                self._select(msg.package.id)
+            self._show_progress(None)
+            return  # halt progress.
+        elif isinstance(msg, StartCollectionMessage):
+            show("Downloading collection %s" % msg.collection.id)
+            self._log_indent += 1
+        elif isinstance(msg, StartPackageMessage):
+            show("Downloading package %s" % msg.package.id)
+        elif isinstance(msg, UpToDateMessage):
+            show("Package %s is up-to-date!" % msg.package.id)
+        # elif isinstance(msg, StaleMessage):
+        #    show('Package %s is out-of-date or corrupt' % msg.package.id)
+        elif isinstance(msg, FinishDownloadMessage):
+            show("Finished downloading %r." % msg.package.id)
+        elif isinstance(msg, StartUnzipMessage):
+            show("Unzipping %s" % msg.package.filename)
+        elif isinstance(msg, FinishCollectionMessage):
+            self._log_indent -= 1
+            show("Finished downloading collection %r." % msg.collection.id)
+            self._clear_mark(msg.collection.id)
+        elif isinstance(msg, FinishPackageMessage):
+            self._clear_mark(msg.package.id)
+        afterid = self.top.after(self._DL_DELAY, self._download_cb, download_iter, ids)
+        self._afterid["_download_cb"] = afterid
+
+    def _select(self, id):
+        for row in range(len(self._table)):
+            if self._table[row, "Identifier"] == id:
+                self._table.select(row)
+                return
+
+    def _color_table(self):
+        # Color rows according to status.
+        for row in range(len(self._table)):
+            bg, sbg = self._ROW_COLOR[self._table[row, "Status"]]
+            fg, sfg = ("black", "white")
+            self._table.rowconfig(
+                row,
+                foreground=fg,
+                selectforeground=sfg,
+                background=bg,
+                selectbackground=sbg,
+            )
+            # Color the marked column
+            self._table.itemconfigure(
+                row, 0, foreground=self._MARK_COLOR[0], background=self._MARK_COLOR[1]
+            )
+
+    def _clear_mark(self, id):
+        for row in range(len(self._table)):
+            if self._table[row, "Identifier"] == id:
+                self._table[row, 0] = ""
+
+    def _mark_all(self, *e):
+        for row in range(len(self._table)):
+            self._table[row, 0] = "X"
+
+    def _table_mark(self, *e):
+        selection = self._table.selected_row()
+        if selection >= 0:
+            if self._table[selection][0] != "":
+                self._table[selection, 0] = ""
+            else:
+                self._table[selection, 0] = "X"
+        self._table.select(delta=1)
+
+    def _show_log(self):
+        text = "\n".join(self._log_messages)
+        ShowText(self.top, "NLTK Downloader Log", text)
+
+    def _package_to_columns(self, pkg):
+        """
+        Given a package, return a list of values describing that
+        package, one for each column in ``self.COLUMNS``.
+        """
+        row = []
+        for column_index, column_name in enumerate(self.COLUMNS):
+            if column_index == 0:  # Mark:
+                row.append("")
+            elif column_name == "Identifier":
+                row.append(pkg.id)
+            elif column_name == "Status":
+                row.append(self._ds.status(pkg))
+            else:
+                attr = column_name.lower().replace(" ", "_")
+                row.append(getattr(pkg, attr, "n/a"))
+        return row
+
+    # /////////////////////////////////////////////////////////////////
+    # External Interface
+    # /////////////////////////////////////////////////////////////////
+
+    def destroy(self, *e):
+        if self._destroyed:
+            return
+        self.top.destroy()
+        self._destroyed = True
+
+    def _destroy(self, *e):
+        if self.top is not None:
+            for afterid in self._afterid.values():
+                self.top.after_cancel(afterid)
+
+        # Abort any download in progress.
+        if self._downloading and self._use_threads:
+            self._abort_download()
+
+        # Make sure the garbage collector destroys these now;
+        # otherwise, they may get destroyed when we're not in the main
+        # thread, which would make Tkinter unhappy.
+        self._column_vars.clear()
+
+    def mainloop(self, *args, **kwargs):
+        self.top.mainloop(*args, **kwargs)
+
+    # /////////////////////////////////////////////////////////////////
+    # HELP
+    # /////////////////////////////////////////////////////////////////
+
+    HELP = textwrap.dedent(
+        """\
+    This tool can be used to download a variety of corpora and models
+    that can be used with NLTK.  Each corpus or model is distributed
+    in a single zip file, known as a \"package file.\"  You can
+    download packages individually, or you can download pre-defined
+    collections of packages.
+
+    When you download a package, it will be saved to the \"download
+    directory.\"  A default download directory is chosen when you run
+
+    the downloader; but you may also select a different download
+    directory.  On Windows, the default download directory is
+
+
+    \"package.\"
+
+    The NLTK downloader can be used to download a variety of corpora,
+    models, and other data packages.
+
+    Keyboard shortcuts::
+      [return]\t Download
+      [up]\t Select previous package
+      [down]\t Select next package
+      [left]\t Select previous tab
+      [right]\t Select next tab
+    """
+    )
+
+    def help(self, *e):
+        # The default font's not very legible; try using 'fixed' instead.
+        try:
+            ShowText(
+                self.top,
+                "Help: NLTK Downloader",
+                self.HELP.strip(),
+                width=75,
+                font="fixed",
+            )
+        except:
+            ShowText(self.top, "Help: NLTK Downloader", self.HELP.strip(), width=75)
+
+    def about(self, *e):
+        ABOUT = "NLTK Downloader\n" + "Written by Edward Loper"
+        TITLE = "About: NLTK Downloader"
+        try:
+            from tkinter.messagebox import Message
+
+            Message(message=ABOUT, title=TITLE).show()
+        except ImportError:
+            ShowText(self.top, TITLE, ABOUT)
+
+    # /////////////////////////////////////////////////////////////////
+    # Progress Bar
+    # /////////////////////////////////////////////////////////////////
+
+    _gradient_width = 5
+
+    def _init_progressbar(self):
+        c = self._progressbar
+        width, height = int(c["width"]), int(c["height"])
+        for i in range(0, (int(c["width"]) * 2) // self._gradient_width):
+            c.create_line(
+                i * self._gradient_width + 20,
+                -20,
+                i * self._gradient_width - height - 20,
+                height + 20,
+                width=self._gradient_width,
+                fill="#%02x0000" % (80 + abs(i % 6 - 3) * 12),
+            )
+        c.addtag_all("gradient")
+        c.itemconfig("gradient", state="hidden")
+
+        # This is used to display progress
+        c.addtag_withtag(
+            "redbox", c.create_rectangle(0, 0, 0, 0, fill=self._PROGRESS_COLOR[0])
+        )
+
+    def _show_progress(self, percent):
+        c = self._progressbar
+        if percent is None:
+            c.coords("redbox", 0, 0, 0, 0)
+            c.itemconfig("gradient", state="hidden")
+        else:
+            width, height = int(c["width"]), int(c["height"])
+            x = percent * int(width) // 100 + 1
+            c.coords("redbox", 0, 0, x, height + 1)
+
+    def _progress_alive(self):
+        c = self._progressbar
+        if not self._downloading:
+            c.itemconfig("gradient", state="hidden")
+        else:
+            c.itemconfig("gradient", state="normal")
+            x1, y1, x2, y2 = c.bbox("gradient")
+            if x1 <= -100:
+                c.move("gradient", (self._gradient_width * 6) - 4, 0)
+            else:
+                c.move("gradient", -4, 0)
+            afterid = self.top.after(200, self._progress_alive)
+            self._afterid["_progress_alive"] = afterid
+
+    # /////////////////////////////////////////////////////////////////
+    # Threaded downloader
+    # /////////////////////////////////////////////////////////////////
+
+    def _download_threaded(self, *e):
+        # If the user tries to start a new download while we're already
+        # downloading something, then abort the current download instead.
+        if self._downloading:
+            self._abort_download()
+            return
+
+        # Change the 'download' button to an 'abort' button.
+        self._download_button["text"] = "Cancel"
+
+        marked = [
+            self._table[row, "Identifier"]
+            for row in range(len(self._table))
+            if self._table[row, 0] != ""
+        ]
+        selection = self._table.selected_row()
+        if not marked and selection is not None:
+            marked = [self._table[selection, "Identifier"]]
+
+        # Create a new data server object for the download operation,
+        # just in case the user modifies our data server during the
+        # download (e.g., clicking 'refresh' or editing the index url).
+        ds = Downloader(self._ds.url, self._ds.download_dir)
+
+        # Start downloading in a separate thread.
+        assert self._download_msg_queue == []
+        assert self._download_abort_queue == []
+        self._DownloadThread(
+            ds,
+            marked,
+            self._download_lock,
+            self._download_msg_queue,
+            self._download_abort_queue,
+        ).start()
+
+        # Monitor the download message queue & display its progress.
+        self._log_indent = 0
+        self._downloading = True
+        self._monitor_message_queue()
+
+        # Display an indication that we're still alive and well by
+        # cycling the progress bar.
+        self._progress_alive()
+
+    def _abort_download(self):
+        if self._downloading:
+            self._download_lock.acquire()
+            self._download_abort_queue.append("abort")
+            self._download_lock.release()
+
+    class _DownloadThread(threading.Thread):
+        def __init__(self, data_server, items, lock, message_queue, abort):
+            self.data_server = data_server
+            self.items = items
+            self.lock = lock
+            self.message_queue = message_queue
+            self.abort = abort
+            threading.Thread.__init__(self)
+
+        def run(self):
+            for msg in self.data_server.incr_download(self.items):
+                self.lock.acquire()
+                self.message_queue.append(msg)
+                # Check if we've been told to kill ourselves:
+                if self.abort:
+                    self.message_queue.append("aborted")
+                    self.lock.release()
+                    return
+                self.lock.release()
+            self.lock.acquire()
+            self.message_queue.append("finished")
+            self.lock.release()
+
+    _MONITOR_QUEUE_DELAY = 100
+
+    def _monitor_message_queue(self):
+        def show(s):
+            self._progresslabel["text"] = s
+            self._log(s)
+
+        # Try to acquire the lock; if it's busy, then just try again later.
+        if not self._download_lock.acquire():
+            return
+        for msg in self._download_msg_queue:
+
+            # Done downloading?
+            if msg == "finished" or msg == "aborted":
+                # self._fill_table(sort=False)
+                self._update_table_status()
+                self._downloading = False
+                self._download_button["text"] = "Download"
+                del self._download_msg_queue[:]
+                del self._download_abort_queue[:]
+                self._download_lock.release()
+                if msg == "aborted":
+                    show("Download aborted!")
+                    self._show_progress(None)
+                else:
+                    afterid = self.top.after(100, self._show_progress, None)
+                    self._afterid["_monitor_message_queue"] = afterid
+                return
+
+            # All other messages
+            elif isinstance(msg, ProgressMessage):
+                self._show_progress(msg.progress)
+            elif isinstance(msg, ErrorMessage):
+                show(msg.message)
+                if msg.package is not None:
+                    self._select(msg.package.id)
+                self._show_progress(None)
+                self._downloading = False
+                return  # halt progress.
+            elif isinstance(msg, StartCollectionMessage):
+                show("Downloading collection %r" % msg.collection.id)
+                self._log_indent += 1
+            elif isinstance(msg, StartPackageMessage):
+                self._ds.clear_status_cache(msg.package.id)
+                show("Downloading package %r" % msg.package.id)
+            elif isinstance(msg, UpToDateMessage):
+                show("Package %s is up-to-date!" % msg.package.id)
+            # elif isinstance(msg, StaleMessage):
+            #    show('Package %s is out-of-date or corrupt; updating it' %
+            #         msg.package.id)
+            elif isinstance(msg, FinishDownloadMessage):
+                show("Finished downloading %r." % msg.package.id)
+            elif isinstance(msg, StartUnzipMessage):
+                show("Unzipping %s" % msg.package.filename)
+            elif isinstance(msg, FinishUnzipMessage):
+                show("Finished installing %s" % msg.package.id)
+            elif isinstance(msg, FinishCollectionMessage):
+                self._log_indent -= 1
+                show("Finished downloading collection %r." % msg.collection.id)
+                self._clear_mark(msg.collection.id)
+            elif isinstance(msg, FinishPackageMessage):
+                self._update_table_status()
+                self._clear_mark(msg.package.id)
+
+        # Let the user know when we're aborting a download (but
+        # waiting for a good point to abort it, so we don't end up
+        # with a partially unzipped package or anything like that).
+        if self._download_abort_queue:
+            self._progresslabel["text"] = "Aborting download..."
+
+        # Clear the message queue and then release the lock
+        del self._download_msg_queue[:]
+        self._download_lock.release()
+
+        # Check the queue again after MONITOR_QUEUE_DELAY msec.
+        afterid = self.top.after(self._MONITOR_QUEUE_DELAY, self._monitor_message_queue)
+        self._afterid["_monitor_message_queue"] = afterid
+
+
+######################################################################
+# Helper Functions
+######################################################################
+# [xx] It may make sense to move these to nltk.internals.
+
+
+def md5_hexdigest(file):
+    """
+    Calculate and return the MD5 checksum for a given file.
+    ``file`` may either be a filename or an open stream.
+    """
+    if isinstance(file, str):
+        with open(file, "rb") as infile:
+            return _md5_hexdigest(infile)
+    return _md5_hexdigest(file)
+
+
+def _md5_hexdigest(fp):
+    md5_digest = md5()
+    while True:
+        block = fp.read(1024 * 16)  # 16k blocks
+        if not block:
+            break
+        md5_digest.update(block)
+    return md5_digest.hexdigest()
+
+
+# change this to periodically yield progress messages?
+# [xx] get rid of topdir parameter -- we should be checking
+# this when we build the index, anyway.
+def unzip(filename, root, verbose=True):
+    """
+    Extract the contents of the zip file ``filename`` into the
+    directory ``root``.
+    """
+    for message in _unzip_iter(filename, root, verbose):
+        if isinstance(message, ErrorMessage):
+            raise Exception(message)
+
+
+def _unzip_iter(filename, root, verbose=True):
+    if verbose:
+        sys.stdout.write("Unzipping %s" % os.path.split(filename)[1])
+        sys.stdout.flush()
+
+    try:
+        zf = zipfile.ZipFile(filename)
+    except zipfile.error as e:
+        yield ErrorMessage(filename, "Error with downloaded zip file")
+        return
+    except Exception as e:
+        yield ErrorMessage(filename, e)
+        return
+
+    zf.extractall(root)
+
+    if verbose:
+        print()
+
+
+######################################################################
+# Index Builder
+######################################################################
+# This may move to a different file sometime.
+
+
+def build_index(root, base_url):
+    """
+    Create a new data.xml index file, by combining the xml description
+    files for various packages and collections.  ``root`` should be the
+    path to a directory containing the package xml and zip files; and
+    the collection xml files.  The ``root`` directory is expected to
+    have the following subdirectories::
+
+      root/
+        packages/ .................. subdirectory for packages
+          corpora/ ................. zip & xml files for corpora
+          grammars/ ................ zip & xml files for grammars
+          taggers/ ................. zip & xml files for taggers
+          tokenizers/ .............. zip & xml files for tokenizers
+          etc.
+        collections/ ............... xml files for collections
+
+    For each package, there should be two files: ``package.zip``
+    (where *package* is the package name)
+    which contains the package itself as a compressed zip file; and
+    ``package.xml``, which is an xml description of the package.  The
+    zipfile ``package.zip`` should expand to a single subdirectory
+    named ``package/``.  The base filename ``package`` must match
+    the identifier given in the package's xml file.
+
+    For each collection, there should be a single file ``collection.zip``
+    describing the collection, where *collection* is the name of the collection.
+
+    All identifiers (for both packages and collections) must be unique.
+    """
+    # Find all packages.
+    packages = []
+    for pkg_xml, zf, subdir in _find_packages(os.path.join(root, "packages")):
+        zipstat = os.stat(zf.filename)
+        url = f"{base_url}/{subdir}/{os.path.split(zf.filename)[1]}"
+        unzipped_size = sum(zf_info.file_size for zf_info in zf.infolist())
+
+        # Fill in several fields of the package xml with calculated values.
+        pkg_xml.set("unzipped_size", "%s" % unzipped_size)
+        pkg_xml.set("size", "%s" % zipstat.st_size)
+        pkg_xml.set("checksum", "%s" % md5_hexdigest(zf.filename))
+        pkg_xml.set("subdir", subdir)
+        # pkg_xml.set('svn_revision', _svn_revision(zf.filename))
+        if not pkg_xml.get("url"):
+            pkg_xml.set("url", url)
+
+        # Record the package.
+        packages.append(pkg_xml)
+
+    # Find all collections
+    collections = list(_find_collections(os.path.join(root, "collections")))
+
+    # Check that all UIDs are unique
+    uids = set()
+    for item in packages + collections:
+        if item.get("id") in uids:
+            raise ValueError("Duplicate UID: %s" % item.get("id"))
+        uids.add(item.get("id"))
+
+    # Put it all together
+    top_elt = ElementTree.Element("nltk_data")
+    top_elt.append(ElementTree.Element("packages"))
+    top_elt[0].extend(sorted(packages, key=lambda package: package.get("id")))
+    top_elt.append(ElementTree.Element("collections"))
+    top_elt[1].extend(sorted(collections, key=lambda collection: collection.get("id")))
+
+    _indent_xml(top_elt)
+    return top_elt
+
+
+def _indent_xml(xml, prefix=""):
+    """
+    Helper for ``build_index()``: Given an XML ``ElementTree``, modify it
+    (and its descendents) ``text`` and ``tail`` attributes to generate
+    an indented tree, where each nested element is indented by 2
+    spaces with respect to its parent.
+    """
+    if len(xml) > 0:
+        xml.text = (xml.text or "").strip() + "\n" + prefix + "  "
+        for child in xml:
+            _indent_xml(child, prefix + "  ")
+        for child in xml[:-1]:
+            child.tail = (child.tail or "").strip() + "\n" + prefix + "  "
+        xml[-1].tail = (xml[-1].tail or "").strip() + "\n" + prefix
+
+
+def _check_package(pkg_xml, zipfilename, zf):
+    """
+    Helper for ``build_index()``: Perform some checks to make sure that
+    the given package is consistent.
+    """
+    # The filename must patch the id given in the XML file.
+    uid = os.path.splitext(os.path.split(zipfilename)[1])[0]
+    if pkg_xml.get("id") != uid:
+        raise ValueError(
+            "package identifier mismatch ({} vs {})".format(pkg_xml.get("id"), uid)
+        )
+
+    # Zip file must expand to a subdir whose name matches uid.
+    if sum((name != uid and not name.startswith(uid + "/")) for name in zf.namelist()):
+        raise ValueError(
+            "Zipfile %s.zip does not expand to a single "
+            "subdirectory %s/" % (uid, uid)
+        )
+
+
+# update for git?
+def _svn_revision(filename):
+    """
+    Helper for ``build_index()``: Calculate the subversion revision
+    number for a given file (by using ``subprocess`` to run ``svn``).
+    """
+    p = subprocess.Popen(
+        ["svn", "status", "-v", filename],
+        stdout=subprocess.PIPE,
+        stderr=subprocess.PIPE,
+    )
+    (stdout, stderr) = p.communicate()
+    if p.returncode != 0 or stderr or not stdout:
+        raise ValueError(
+            "Error determining svn_revision for %s: %s"
+            % (os.path.split(filename)[1], textwrap.fill(stderr))
+        )
+    return stdout.split()[2]
+
+
+def _find_collections(root):
+    """
+    Helper for ``build_index()``: Yield a list of ElementTree.Element
+    objects, each holding the xml for a single package collection.
+    """
+    for dirname, _subdirs, files in os.walk(root):
+        for filename in files:
+            if filename.endswith(".xml"):
+                xmlfile = os.path.join(dirname, filename)
+                yield ElementTree.parse(xmlfile).getroot()
+
+
+def _find_packages(root):
+    """
+    Helper for ``build_index()``: Yield a list of tuples
+    ``(pkg_xml, zf, subdir)``, where:
+      - ``pkg_xml`` is an ``ElementTree.Element`` holding the xml for a
+        package
+      - ``zf`` is a ``zipfile.ZipFile`` for the package's contents.
+      - ``subdir`` is the subdirectory (relative to ``root``) where
+        the package was found (e.g. 'corpora' or 'grammars').
+    """
+    from nltk.corpus.reader.util import _path_from
+
+    # Find all packages.
+    packages = []
+    for dirname, subdirs, files in os.walk(root):
+        relpath = "/".join(_path_from(root, dirname))
+        for filename in files:
+            if filename.endswith(".xml"):
+                xmlfilename = os.path.join(dirname, filename)
+                zipfilename = xmlfilename[:-4] + ".zip"
+                try:
+                    zf = zipfile.ZipFile(zipfilename)
+                except Exception as e:
+                    raise ValueError(f"Error reading file {zipfilename!r}!\n{e}") from e
+                try:
+                    pkg_xml = ElementTree.parse(xmlfilename).getroot()
+                except Exception as e:
+                    raise ValueError(f"Error reading file {xmlfilename!r}!\n{e}") from e
+
+                # Check that the UID matches the filename
+                uid = os.path.split(xmlfilename[:-4])[1]
+                if pkg_xml.get("id") != uid:
+                    raise ValueError(
+                        "package identifier mismatch (%s "
+                        "vs %s)" % (pkg_xml.get("id"), uid)
+                    )
+
+                # Check that the zipfile expands to a subdir whose
+                # name matches the uid.
+                if sum(
+                    (name != uid and not name.startswith(uid + "/"))
+                    for name in zf.namelist()
+                ):
+                    raise ValueError(
+                        "Zipfile %s.zip does not expand to a "
+                        "single subdirectory %s/" % (uid, uid)
+                    )
+
+                yield pkg_xml, zf, relpath
+
+            elif filename.endswith(".zip"):
+                # Warn user in case a .xml does not exist for a .zip
+                resourcename = os.path.splitext(filename)[0]
+                xmlfilename = os.path.join(dirname, resourcename + ".xml")
+                if not os.path.exists(xmlfilename):
+                    warnings.warn(
+                        f"{filename} exists, but {resourcename + '.xml'} cannot be found! "
+                        f"This could mean that {resourcename} can not be downloaded.",
+                        stacklevel=2,
+                    )
+
+        # Don't recurse into svn subdirectories:
+        try:
+            subdirs.remove(".svn")
+        except ValueError:
+            pass
+
+
+######################################################################
+# Main:
+######################################################################
+
+# There should be a command-line interface
+
+# Aliases
+_downloader = Downloader()
+download = _downloader.download
+
+
+def download_shell():
+    DownloaderShell(_downloader).run()
+
+
+def download_gui():
+    DownloaderGUI(_downloader).mainloop()
+
+
+def update():
+    _downloader.update()
+
+
+if __name__ == "__main__":
+    from optparse import OptionParser
+
+    parser = OptionParser()
+    parser.add_option(
+        "-d",
+        "--dir",
+        dest="dir",
+        help="download package to directory DIR",
+        metavar="DIR",
+    )
+    parser.add_option(
+        "-q",
+        "--quiet",
+        dest="quiet",
+        action="store_true",
+        default=False,
+        help="work quietly",
+    )
+    parser.add_option(
+        "-f",
+        "--force",
+        dest="force",
+        action="store_true",
+        default=False,
+        help="download even if already installed",
+    )
+    parser.add_option(
+        "-e",
+        "--exit-on-error",
+        dest="halt_on_error",
+        action="store_true",
+        default=False,
+        help="exit if an error occurs",
+    )
+    parser.add_option(
+        "-u",
+        "--url",
+        dest="server_index_url",
+        default=os.environ.get("NLTK_DOWNLOAD_URL"),
+        help="download server index url",
+    )
+
+    (options, args) = parser.parse_args()
+
+    downloader = Downloader(server_index_url=options.server_index_url)
+
+    if args:
+        for pkg_id in args:
+            rv = downloader.download(
+                info_or_id=pkg_id,
+                download_dir=options.dir,
+                quiet=options.quiet,
+                force=options.force,
+                halt_on_error=options.halt_on_error,
+            )
+            if rv == False and options.halt_on_error:
+                break
+    else:
+        downloader.download(
+            download_dir=options.dir,
+            quiet=options.quiet,
+            force=options.force,
+            halt_on_error=options.halt_on_error,
+        )

llmeval-env/lib/python3.10/site-packages/nltk/grammar.py

@@ -0,0 +1,1708 @@
+# Natural Language Toolkit: Context Free Grammars
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+#         Edward Loper <[email protected]>
+#         Jason Narad <[email protected]>
+#         Peter Ljunglöf <[email protected]>
+#         Tom Aarsen <>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+"""
+Basic data classes for representing context free grammars.  A
+"grammar" specifies which trees can represent the structure of a
+given text.  Each of these trees is called a "parse tree" for the
+text (or simply a "parse").  In a "context free" grammar, the set of
+parse trees for any piece of a text can depend only on that piece, and
+not on the rest of the text (i.e., the piece's context).  Context free
+grammars are often used to find possible syntactic structures for
+sentences.  In this context, the leaves of a parse tree are word
+tokens; and the node values are phrasal categories, such as ``NP``
+and ``VP``.
+
+The ``CFG`` class is used to encode context free grammars.  Each
+``CFG`` consists of a start symbol and a set of productions.
+The "start symbol" specifies the root node value for parse trees.  For example,
+the start symbol for syntactic parsing is usually ``S``.  Start
+symbols are encoded using the ``Nonterminal`` class, which is discussed
+below.
+
+A Grammar's "productions" specify what parent-child relationships a parse
+tree can contain.  Each production specifies that a particular
+node can be the parent of a particular set of children.  For example,
+the production ``<S> -> <NP> <VP>`` specifies that an ``S`` node can
+be the parent of an ``NP`` node and a ``VP`` node.
+
+Grammar productions are implemented by the ``Production`` class.
+Each ``Production`` consists of a left hand side and a right hand
+side.  The "left hand side" is a ``Nonterminal`` that specifies the
+node type for a potential parent; and the "right hand side" is a list
+that specifies allowable children for that parent.  This lists
+consists of ``Nonterminals`` and text types: each ``Nonterminal``
+indicates that the corresponding child may be a ``TreeToken`` with the
+specified node type; and each text type indicates that the
+corresponding child may be a ``Token`` with the with that type.
+
+The ``Nonterminal`` class is used to distinguish node values from leaf
+values.  This prevents the grammar from accidentally using a leaf
+value (such as the English word "A") as the node of a subtree.  Within
+a ``CFG``, all node values are wrapped in the ``Nonterminal``
+class. Note, however, that the trees that are specified by the grammar do
+*not* include these ``Nonterminal`` wrappers.
+
+Grammars can also be given a more procedural interpretation.  According to
+this interpretation, a Grammar specifies any tree structure *tree* that
+can be produced by the following procedure:
+
+| Set tree to the start symbol
+| Repeat until tree contains no more nonterminal leaves:
+|   Choose a production prod with whose left hand side
+|     lhs is a nonterminal leaf of tree.
+|   Replace the nonterminal leaf with a subtree, whose node
+|     value is the value wrapped by the nonterminal lhs, and
+|     whose children are the right hand side of prod.
+
+The operation of replacing the left hand side (*lhs*) of a production
+with the right hand side (*rhs*) in a tree (*tree*) is known as
+"expanding" *lhs* to *rhs* in *tree*.
+"""
+import re
+from functools import total_ordering
+
+from nltk.featstruct import SLASH, TYPE, FeatDict, FeatStruct, FeatStructReader
+from nltk.internals import raise_unorderable_types
+from nltk.probability import ImmutableProbabilisticMixIn
+from nltk.util import invert_graph, transitive_closure
+
+#################################################################
+# Nonterminal
+#################################################################
+
+
+@total_ordering
+class Nonterminal:
+    """
+    A non-terminal symbol for a context free grammar.  ``Nonterminal``
+    is a wrapper class for node values; it is used by ``Production``
+    objects to distinguish node values from leaf values.
+    The node value that is wrapped by a ``Nonterminal`` is known as its
+    "symbol".  Symbols are typically strings representing phrasal
+    categories (such as ``"NP"`` or ``"VP"``).  However, more complex
+    symbol types are sometimes used (e.g., for lexicalized grammars).
+    Since symbols are node values, they must be immutable and
+    hashable.  Two ``Nonterminals`` are considered equal if their
+    symbols are equal.
+
+    :see: ``CFG``, ``Production``
+    :type _symbol: any
+    :ivar _symbol: The node value corresponding to this
+        ``Nonterminal``.  This value must be immutable and hashable.
+    """
+
+    def __init__(self, symbol):
+        """
+        Construct a new non-terminal from the given symbol.
+
+        :type symbol: any
+        :param symbol: The node value corresponding to this
+            ``Nonterminal``.  This value must be immutable and
+            hashable.
+        """
+        self._symbol = symbol
+
+    def symbol(self):
+        """
+        Return the node value corresponding to this ``Nonterminal``.
+
+        :rtype: (any)
+        """
+        return self._symbol
+
+    def __eq__(self, other):
+        """
+        Return True if this non-terminal is equal to ``other``.  In
+        particular, return True if ``other`` is a ``Nonterminal``
+        and this non-terminal's symbol is equal to ``other`` 's symbol.
+
+        :rtype: bool
+        """
+        return type(self) == type(other) and self._symbol == other._symbol
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, Nonterminal):
+            raise_unorderable_types("<", self, other)
+        return self._symbol < other._symbol
+
+    def __hash__(self):
+        return hash(self._symbol)
+
+    def __repr__(self):
+        """
+        Return a string representation for this ``Nonterminal``.
+
+        :rtype: str
+        """
+        if isinstance(self._symbol, str):
+            return "%s" % self._symbol
+        else:
+            return "%s" % repr(self._symbol)
+
+    def __str__(self):
+        """
+        Return a string representation for this ``Nonterminal``.
+
+        :rtype: str
+        """
+        if isinstance(self._symbol, str):
+            return "%s" % self._symbol
+        else:
+            return "%s" % repr(self._symbol)
+
+    def __div__(self, rhs):
+        """
+        Return a new nonterminal whose symbol is ``A/B``, where ``A`` is
+        the symbol for this nonterminal, and ``B`` is the symbol for rhs.
+
+        :param rhs: The nonterminal used to form the right hand side
+            of the new nonterminal.
+        :type rhs: Nonterminal
+        :rtype: Nonterminal
+        """
+        return Nonterminal(f"{self._symbol}/{rhs._symbol}")
+
+    def __truediv__(self, rhs):
+        """
+        Return a new nonterminal whose symbol is ``A/B``, where ``A`` is
+        the symbol for this nonterminal, and ``B`` is the symbol for rhs.
+        This function allows use of the slash ``/`` operator with
+        the future import of division.
+
+        :param rhs: The nonterminal used to form the right hand side
+            of the new nonterminal.
+        :type rhs: Nonterminal
+        :rtype: Nonterminal
+        """
+        return self.__div__(rhs)
+
+
+def nonterminals(symbols):
+    """
+    Given a string containing a list of symbol names, return a list of
+    ``Nonterminals`` constructed from those symbols.
+
+    :param symbols: The symbol name string.  This string can be
+        delimited by either spaces or commas.
+    :type symbols: str
+    :return: A list of ``Nonterminals`` constructed from the symbol
+        names given in ``symbols``.  The ``Nonterminals`` are sorted
+        in the same order as the symbols names.
+    :rtype: list(Nonterminal)
+    """
+    if "," in symbols:
+        symbol_list = symbols.split(",")
+    else:
+        symbol_list = symbols.split()
+    return [Nonterminal(s.strip()) for s in symbol_list]
+
+
+class FeatStructNonterminal(FeatDict, Nonterminal):
+    """A feature structure that's also a nonterminal.  It acts as its
+    own symbol, and automatically freezes itself when hashed."""
+
+    def __hash__(self):
+        self.freeze()
+        return FeatStruct.__hash__(self)
+
+    def symbol(self):
+        return self
+
+
+def is_nonterminal(item):
+    """
+    :return: True if the item is a ``Nonterminal``.
+    :rtype: bool
+    """
+    return isinstance(item, Nonterminal)
+
+
+#################################################################
+# Terminals
+#################################################################
+
+
+def is_terminal(item):
+    """
+    Return True if the item is a terminal, which currently is
+    if it is hashable and not a ``Nonterminal``.
+
+    :rtype: bool
+    """
+    return hasattr(item, "__hash__") and not isinstance(item, Nonterminal)
+
+
+#################################################################
+# Productions
+#################################################################
+
+
+@total_ordering
+class Production:
+    """
+    A grammar production.  Each production maps a single symbol
+    on the "left-hand side" to a sequence of symbols on the
+    "right-hand side".  (In the case of context-free productions,
+    the left-hand side must be a ``Nonterminal``, and the right-hand
+    side is a sequence of terminals and ``Nonterminals``.)
+    "terminals" can be any immutable hashable object that is
+    not a ``Nonterminal``.  Typically, terminals are strings
+    representing words, such as ``"dog"`` or ``"under"``.
+
+    :see: ``CFG``
+    :see: ``DependencyGrammar``
+    :see: ``Nonterminal``
+    :type _lhs: Nonterminal
+    :ivar _lhs: The left-hand side of the production.
+    :type _rhs: tuple(Nonterminal, terminal)
+    :ivar _rhs: The right-hand side of the production.
+    """
+
+    def __init__(self, lhs, rhs):
+        """
+        Construct a new ``Production``.
+
+        :param lhs: The left-hand side of the new ``Production``.
+        :type lhs: Nonterminal
+        :param rhs: The right-hand side of the new ``Production``.
+        :type rhs: sequence(Nonterminal and terminal)
+        """
+        if isinstance(rhs, str):
+            raise TypeError(
+                "production right hand side should be a list, " "not a string"
+            )
+        self._lhs = lhs
+        self._rhs = tuple(rhs)
+
+    def lhs(self):
+        """
+        Return the left-hand side of this ``Production``.
+
+        :rtype: Nonterminal
+        """
+        return self._lhs
+
+    def rhs(self):
+        """
+        Return the right-hand side of this ``Production``.
+
+        :rtype: sequence(Nonterminal and terminal)
+        """
+        return self._rhs
+
+    def __len__(self):
+        """
+        Return the length of the right-hand side.
+
+        :rtype: int
+        """
+        return len(self._rhs)
+
+    def is_nonlexical(self):
+        """
+        Return True if the right-hand side only contains ``Nonterminals``
+
+        :rtype: bool
+        """
+        return all(is_nonterminal(n) for n in self._rhs)
+
+    def is_lexical(self):
+        """
+        Return True if the right-hand contain at least one terminal token.
+
+        :rtype: bool
+        """
+        return not self.is_nonlexical()
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``Production``.
+
+        :rtype: str
+        """
+        result = "%s -> " % repr(self._lhs)
+        result += " ".join(repr(el) for el in self._rhs)
+        return result
+
+    def __repr__(self):
+        """
+        Return a concise string representation of the ``Production``.
+
+        :rtype: str
+        """
+        return "%s" % self
+
+    def __eq__(self, other):
+        """
+        Return True if this ``Production`` is equal to ``other``.
+
+        :rtype: bool
+        """
+        return (
+            type(self) == type(other)
+            and self._lhs == other._lhs
+            and self._rhs == other._rhs
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, Production):
+            raise_unorderable_types("<", self, other)
+        return (self._lhs, self._rhs) < (other._lhs, other._rhs)
+
+    def __hash__(self):
+        """
+        Return a hash value for the ``Production``.
+
+        :rtype: int
+        """
+        return hash((self._lhs, self._rhs))
+
+
+class DependencyProduction(Production):
+    """
+    A dependency grammar production.  Each production maps a single
+    head word to an unordered list of one or more modifier words.
+    """
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``DependencyProduction``.
+
+        :rtype: str
+        """
+        result = f"'{self._lhs}' ->"
+        for elt in self._rhs:
+            result += f" '{elt}'"
+        return result
+
+
+class ProbabilisticProduction(Production, ImmutableProbabilisticMixIn):
+    """
+    A probabilistic context free grammar production.
+    A PCFG ``ProbabilisticProduction`` is essentially just a ``Production`` that
+    has an associated probability, which represents how likely it is that
+    this production will be used.  In particular, the probability of a
+    ``ProbabilisticProduction`` records the likelihood that its right-hand side is
+    the correct instantiation for any given occurrence of its left-hand side.
+
+    :see: ``Production``
+    """
+
+    def __init__(self, lhs, rhs, **prob):
+        """
+        Construct a new ``ProbabilisticProduction``.
+
+        :param lhs: The left-hand side of the new ``ProbabilisticProduction``.
+        :type lhs: Nonterminal
+        :param rhs: The right-hand side of the new ``ProbabilisticProduction``.
+        :type rhs: sequence(Nonterminal and terminal)
+        :param prob: Probability parameters of the new ``ProbabilisticProduction``.
+        """
+        ImmutableProbabilisticMixIn.__init__(self, **prob)
+        Production.__init__(self, lhs, rhs)
+
+    def __str__(self):
+        return super().__str__() + (
+            " [1.0]" if (self.prob() == 1.0) else " [%g]" % self.prob()
+        )
+
+    def __eq__(self, other):
+        return (
+            type(self) == type(other)
+            and self._lhs == other._lhs
+            and self._rhs == other._rhs
+            and self.prob() == other.prob()
+        )
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __hash__(self):
+        return hash((self._lhs, self._rhs, self.prob()))
+
+
+#################################################################
+# Grammars
+#################################################################
+
+
+class CFG:
+    """
+    A context-free grammar.  A grammar consists of a start state and
+    a set of productions.  The set of terminals and nonterminals is
+    implicitly specified by the productions.
+
+    If you need efficient key-based access to productions, you
+    can use a subclass to implement it.
+    """
+
+    def __init__(self, start, productions, calculate_leftcorners=True):
+        """
+        Create a new context-free grammar, from the given start state
+        and set of ``Production`` instances.
+
+        :param start: The start symbol
+        :type start: Nonterminal
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        :param calculate_leftcorners: False if we don't want to calculate the
+            leftcorner relation. In that case, some optimized chart parsers won't work.
+        :type calculate_leftcorners: bool
+        """
+        if not is_nonterminal(start):
+            raise TypeError(
+                "start should be a Nonterminal object,"
+                " not a %s" % type(start).__name__
+            )
+
+        self._start = start
+        self._productions = productions
+        self._categories = {prod.lhs() for prod in productions}
+        self._calculate_indexes()
+        self._calculate_grammar_forms()
+        if calculate_leftcorners:
+            self._calculate_leftcorners()
+
+    def _calculate_indexes(self):
+        self._lhs_index = {}
+        self._rhs_index = {}
+        self._empty_index = {}
+        self._lexical_index = {}
+        for prod in self._productions:
+            # Left hand side.
+            lhs = prod._lhs
+            if lhs not in self._lhs_index:
+                self._lhs_index[lhs] = []
+            self._lhs_index[lhs].append(prod)
+            if prod._rhs:
+                # First item in right hand side.
+                rhs0 = prod._rhs[0]
+                if rhs0 not in self._rhs_index:
+                    self._rhs_index[rhs0] = []
+                self._rhs_index[rhs0].append(prod)
+            else:
+                # The right hand side is empty.
+                self._empty_index[prod.lhs()] = prod
+            # Lexical tokens in the right hand side.
+            for token in prod._rhs:
+                if is_terminal(token):
+                    self._lexical_index.setdefault(token, set()).add(prod)
+
+    def _calculate_leftcorners(self):
+        # Calculate leftcorner relations, for use in optimized parsing.
+        self._immediate_leftcorner_categories = {cat: {cat} for cat in self._categories}
+        self._immediate_leftcorner_words = {cat: set() for cat in self._categories}
+        for prod in self.productions():
+            if len(prod) > 0:
+                cat, left = prod.lhs(), prod.rhs()[0]
+                if is_nonterminal(left):
+                    self._immediate_leftcorner_categories[cat].add(left)
+                else:
+                    self._immediate_leftcorner_words[cat].add(left)
+
+        lc = transitive_closure(self._immediate_leftcorner_categories, reflexive=True)
+        self._leftcorners = lc
+        self._leftcorner_parents = invert_graph(lc)
+
+        nr_leftcorner_categories = sum(
+            map(len, self._immediate_leftcorner_categories.values())
+        )
+        nr_leftcorner_words = sum(map(len, self._immediate_leftcorner_words.values()))
+        if nr_leftcorner_words > nr_leftcorner_categories > 10000:
+            # If the grammar is big, the leftcorner-word dictionary will be too large.
+            # In that case it is better to calculate the relation on demand.
+            self._leftcorner_words = None
+            return
+
+        self._leftcorner_words = {}
+        for cat in self._leftcorners:
+            lefts = self._leftcorners[cat]
+            lc = self._leftcorner_words[cat] = set()
+            for left in lefts:
+                lc.update(self._immediate_leftcorner_words.get(left, set()))
+
+    @classmethod
+    def fromstring(cls, input, encoding=None):
+        """
+        Return the grammar instance corresponding to the input string(s).
+
+        :param input: a grammar, either in the form of a string or as a list of strings.
+        """
+        start, productions = read_grammar(
+            input, standard_nonterm_parser, encoding=encoding
+        )
+        return cls(start, productions)
+
+    def start(self):
+        """
+        Return the start symbol of the grammar
+
+        :rtype: Nonterminal
+        """
+        return self._start
+
+    # tricky to balance readability and efficiency here!
+    # can't use set operations as they don't preserve ordering
+    def productions(self, lhs=None, rhs=None, empty=False):
+        """
+        Return the grammar productions, filtered by the left-hand side
+        or the first item in the right-hand side.
+
+        :param lhs: Only return productions with the given left-hand side.
+        :param rhs: Only return productions with the given first item
+            in the right-hand side.
+        :param empty: Only return productions with an empty right-hand side.
+        :return: A list of productions matching the given constraints.
+        :rtype: list(Production)
+        """
+        if rhs and empty:
+            raise ValueError(
+                "You cannot select empty and non-empty " "productions at the same time."
+            )
+
+        # no constraints so return everything
+        if not lhs and not rhs:
+            if not empty:
+                return self._productions
+            else:
+                return self._empty_index.values()
+
+        # only lhs specified so look up its index
+        elif lhs and not rhs:
+            if not empty:
+                return self._lhs_index.get(lhs, [])
+            elif lhs in self._empty_index:
+                return [self._empty_index[lhs]]
+            else:
+                return []
+
+        # only rhs specified so look up its index
+        elif rhs and not lhs:
+            return self._rhs_index.get(rhs, [])
+
+        # intersect
+        else:
+            return [
+                prod
+                for prod in self._lhs_index.get(lhs, [])
+                if prod in self._rhs_index.get(rhs, [])
+            ]
+
+    def leftcorners(self, cat):
+        """
+        Return the set of all nonterminals that the given nonterminal
+        can start with, including itself.
+
+        This is the reflexive, transitive closure of the immediate
+        leftcorner relation:  (A > B)  iff  (A -> B beta)
+
+        :param cat: the parent of the leftcorners
+        :type cat: Nonterminal
+        :return: the set of all leftcorners
+        :rtype: set(Nonterminal)
+        """
+        return self._leftcorners.get(cat, {cat})
+
+    def is_leftcorner(self, cat, left):
+        """
+        True if left is a leftcorner of cat, where left can be a
+        terminal or a nonterminal.
+
+        :param cat: the parent of the leftcorner
+        :type cat: Nonterminal
+        :param left: the suggested leftcorner
+        :type left: Terminal or Nonterminal
+        :rtype: bool
+        """
+        if is_nonterminal(left):
+            return left in self.leftcorners(cat)
+        elif self._leftcorner_words:
+            return left in self._leftcorner_words.get(cat, set())
+        else:
+            return any(
+                left in self._immediate_leftcorner_words.get(parent, set())
+                for parent in self.leftcorners(cat)
+            )
+
+    def leftcorner_parents(self, cat):
+        """
+        Return the set of all nonterminals for which the given category
+        is a left corner. This is the inverse of the leftcorner relation.
+
+        :param cat: the suggested leftcorner
+        :type cat: Nonterminal
+        :return: the set of all parents to the leftcorner
+        :rtype: set(Nonterminal)
+        """
+        return self._leftcorner_parents.get(cat, {cat})
+
+    def check_coverage(self, tokens):
+        """
+        Check whether the grammar rules cover the given list of tokens.
+        If not, then raise an exception.
+
+        :type tokens: list(str)
+        """
+        missing = [tok for tok in tokens if not self._lexical_index.get(tok)]
+        if missing:
+            missing = ", ".join(f"{w!r}" for w in missing)
+            raise ValueError(
+                "Grammar does not cover some of the " "input words: %r." % missing
+            )
+
+    def _calculate_grammar_forms(self):
+        """
+        Pre-calculate of which form(s) the grammar is.
+        """
+        prods = self._productions
+        self._is_lexical = all(p.is_lexical() for p in prods)
+        self._is_nonlexical = all(p.is_nonlexical() for p in prods if len(p) != 1)
+        self._min_len = min(len(p) for p in prods)
+        self._max_len = max(len(p) for p in prods)
+        self._all_unary_are_lexical = all(p.is_lexical() for p in prods if len(p) == 1)
+
+    def is_lexical(self):
+        """
+        Return True if all productions are lexicalised.
+        """
+        return self._is_lexical
+
+    def is_nonlexical(self):
+        """
+        Return True if all lexical rules are "preterminals", that is,
+        unary rules which can be separated in a preprocessing step.
+
+        This means that all productions are of the forms
+        A -> B1 ... Bn (n>=0), or A -> "s".
+
+        Note: is_lexical() and is_nonlexical() are not opposites.
+        There are grammars which are neither, and grammars which are both.
+        """
+        return self._is_nonlexical
+
+    def min_len(self):
+        """
+        Return the right-hand side length of the shortest grammar production.
+        """
+        return self._min_len
+
+    def max_len(self):
+        """
+        Return the right-hand side length of the longest grammar production.
+        """
+        return self._max_len
+
+    def is_nonempty(self):
+        """
+        Return True if there are no empty productions.
+        """
+        return self._min_len > 0
+
+    def is_binarised(self):
+        """
+        Return True if all productions are at most binary.
+        Note that there can still be empty and unary productions.
+        """
+        return self._max_len <= 2
+
+    def is_flexible_chomsky_normal_form(self):
+        """
+        Return True if all productions are of the forms
+        A -> B C, A -> B, or A -> "s".
+        """
+        return self.is_nonempty() and self.is_nonlexical() and self.is_binarised()
+
+    def is_chomsky_normal_form(self):
+        """
+        Return True if the grammar is of Chomsky Normal Form, i.e. all productions
+        are of the form A -> B C, or A -> "s".
+        """
+        return self.is_flexible_chomsky_normal_form() and self._all_unary_are_lexical
+
+    def chomsky_normal_form(self, new_token_padding="@$@", flexible=False):
+        """
+        Returns a new Grammar that is in chomsky normal
+
+        :param: new_token_padding
+            Customise new rule formation during binarisation
+        """
+        if self.is_chomsky_normal_form():
+            return self
+        if self.productions(empty=True):
+            raise ValueError(
+                "Grammar has Empty rules. " "Cannot deal with them at the moment"
+            )
+
+        # check for mixed rules
+        for rule in self.productions():
+            if rule.is_lexical() and len(rule.rhs()) > 1:
+                raise ValueError(
+                    f"Cannot handled mixed rule {rule.lhs()} => {rule.rhs()}"
+                )
+
+        step1 = CFG.eliminate_start(self)
+        step2 = CFG.binarize(step1, new_token_padding)
+        if flexible:
+            return step2
+        step3 = CFG.remove_unitary_rules(step2)
+        step4 = CFG(step3.start(), list(set(step3.productions())))
+        return step4
+
+    @classmethod
+    def remove_unitary_rules(cls, grammar):
+        """
+        Remove nonlexical unitary rules and convert them to
+        lexical
+        """
+        result = []
+        unitary = []
+        for rule in grammar.productions():
+            if len(rule) == 1 and rule.is_nonlexical():
+                unitary.append(rule)
+            else:
+                result.append(rule)
+
+        while unitary:
+            rule = unitary.pop(0)
+            for item in grammar.productions(lhs=rule.rhs()[0]):
+                new_rule = Production(rule.lhs(), item.rhs())
+                if len(new_rule) != 1 or new_rule.is_lexical():
+                    result.append(new_rule)
+                else:
+                    unitary.append(new_rule)
+
+        n_grammar = CFG(grammar.start(), result)
+        return n_grammar
+
+    @classmethod
+    def binarize(cls, grammar, padding="@$@"):
+        """
+        Convert all non-binary rules into binary by introducing
+        new tokens.
+        Example::
+
+            Original:
+                A => B C D
+            After Conversion:
+                A => B A@$@B
+                A@$@B => C D
+        """
+        result = []
+
+        for rule in grammar.productions():
+            if len(rule.rhs()) > 2:
+                # this rule needs to be broken down
+                left_side = rule.lhs()
+                for k in range(0, len(rule.rhs()) - 2):
+                    tsym = rule.rhs()[k]
+                    new_sym = Nonterminal(left_side.symbol() + padding + tsym.symbol())
+                    new_production = Production(left_side, (tsym, new_sym))
+                    left_side = new_sym
+                    result.append(new_production)
+                last_prd = Production(left_side, rule.rhs()[-2:])
+                result.append(last_prd)
+            else:
+                result.append(rule)
+
+        n_grammar = CFG(grammar.start(), result)
+        return n_grammar
+
+    @classmethod
+    def eliminate_start(cls, grammar):
+        """
+        Eliminate start rule in case it appears on RHS
+        Example: S -> S0 S1 and S0 -> S1 S
+        Then another rule S0_Sigma -> S is added
+        """
+        start = grammar.start()
+        result = []
+        need_to_add = None
+        for rule in grammar.productions():
+            if start in rule.rhs():
+                need_to_add = True
+            result.append(rule)
+        if need_to_add:
+            start = Nonterminal("S0_SIGMA")
+            result.append(Production(start, [grammar.start()]))
+            n_grammar = CFG(start, result)
+            return n_grammar
+        return grammar
+
+    def __repr__(self):
+        return "<Grammar with %d productions>" % len(self._productions)
+
+    def __str__(self):
+        result = "Grammar with %d productions" % len(self._productions)
+        result += " (start state = %r)" % self._start
+        for production in self._productions:
+            result += "\n    %s" % production
+        return result
+
+
+class FeatureGrammar(CFG):
+    """
+    A feature-based grammar.  This is equivalent to a
+    ``CFG`` whose nonterminals are all
+    ``FeatStructNonterminal``.
+
+    A grammar consists of a start state and a set of
+    productions.  The set of terminals and nonterminals
+    is implicitly specified by the productions.
+    """
+
+    def __init__(self, start, productions):
+        """
+        Create a new feature-based grammar, from the given start
+        state and set of ``Productions``.
+
+        :param start: The start symbol
+        :type start: FeatStructNonterminal
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        """
+        CFG.__init__(self, start, productions)
+
+    # The difference with CFG is that the productions are
+    # indexed on the TYPE feature of the nonterminals.
+    # This is calculated by the method _get_type_if_possible().
+
+    def _calculate_indexes(self):
+        self._lhs_index = {}
+        self._rhs_index = {}
+        self._empty_index = {}
+        self._empty_productions = []
+        self._lexical_index = {}
+        for prod in self._productions:
+            # Left hand side.
+            lhs = self._get_type_if_possible(prod._lhs)
+            if lhs not in self._lhs_index:
+                self._lhs_index[lhs] = []
+            self._lhs_index[lhs].append(prod)
+            if prod._rhs:
+                # First item in right hand side.
+                rhs0 = self._get_type_if_possible(prod._rhs[0])
+                if rhs0 not in self._rhs_index:
+                    self._rhs_index[rhs0] = []
+                self._rhs_index[rhs0].append(prod)
+            else:
+                # The right hand side is empty.
+                if lhs not in self._empty_index:
+                    self._empty_index[lhs] = []
+                self._empty_index[lhs].append(prod)
+                self._empty_productions.append(prod)
+            # Lexical tokens in the right hand side.
+            for token in prod._rhs:
+                if is_terminal(token):
+                    self._lexical_index.setdefault(token, set()).add(prod)
+
+    @classmethod
+    def fromstring(
+        cls, input, features=None, logic_parser=None, fstruct_reader=None, encoding=None
+    ):
+        """
+        Return a feature structure based grammar.
+
+        :param input: a grammar, either in the form of a string or else
+        as a list of strings.
+        :param features: a tuple of features (default: SLASH, TYPE)
+        :param logic_parser: a parser for lambda-expressions,
+        by default, ``LogicParser()``
+        :param fstruct_reader: a feature structure parser
+        (only if features and logic_parser is None)
+        """
+        if features is None:
+            features = (SLASH, TYPE)
+
+        if fstruct_reader is None:
+            fstruct_reader = FeatStructReader(
+                features, FeatStructNonterminal, logic_parser=logic_parser
+            )
+        elif logic_parser is not None:
+            raise Exception(
+                "'logic_parser' and 'fstruct_reader' must " "not both be set"
+            )
+
+        start, productions = read_grammar(
+            input, fstruct_reader.read_partial, encoding=encoding
+        )
+        return cls(start, productions)
+
+    def productions(self, lhs=None, rhs=None, empty=False):
+        """
+        Return the grammar productions, filtered by the left-hand side
+        or the first item in the right-hand side.
+
+        :param lhs: Only return productions with the given left-hand side.
+        :param rhs: Only return productions with the given first item
+            in the right-hand side.
+        :param empty: Only return productions with an empty right-hand side.
+        :rtype: list(Production)
+        """
+        if rhs and empty:
+            raise ValueError(
+                "You cannot select empty and non-empty " "productions at the same time."
+            )
+
+        # no constraints so return everything
+        if not lhs and not rhs:
+            if empty:
+                return self._empty_productions
+            else:
+                return self._productions
+
+        # only lhs specified so look up its index
+        elif lhs and not rhs:
+            if empty:
+                return self._empty_index.get(self._get_type_if_possible(lhs), [])
+            else:
+                return self._lhs_index.get(self._get_type_if_possible(lhs), [])
+
+        # only rhs specified so look up its index
+        elif rhs and not lhs:
+            return self._rhs_index.get(self._get_type_if_possible(rhs), [])
+
+        # intersect
+        else:
+            return [
+                prod
+                for prod in self._lhs_index.get(self._get_type_if_possible(lhs), [])
+                if prod in self._rhs_index.get(self._get_type_if_possible(rhs), [])
+            ]
+
+    def leftcorners(self, cat):
+        """
+        Return the set of all words that the given category can start with.
+        Also called the "first set" in compiler construction.
+        """
+        raise NotImplementedError("Not implemented yet")
+
+    def leftcorner_parents(self, cat):
+        """
+        Return the set of all categories for which the given category
+        is a left corner.
+        """
+        raise NotImplementedError("Not implemented yet")
+
+    def _get_type_if_possible(self, item):
+        """
+        Helper function which returns the ``TYPE`` feature of the ``item``,
+        if it exists, otherwise it returns the ``item`` itself
+        """
+        if isinstance(item, dict) and TYPE in item:
+            return FeatureValueType(item[TYPE])
+        else:
+            return item
+
+
+@total_ordering
+class FeatureValueType:
+    """
+    A helper class for ``FeatureGrammars``, designed to be different
+    from ordinary strings.  This is to stop the ``FeatStruct``
+    ``FOO[]`` from being compare equal to the terminal "FOO".
+    """
+
+    def __init__(self, value):
+        self._value = value
+
+    def __repr__(self):
+        return "<%s>" % self._value
+
+    def __eq__(self, other):
+        return type(self) == type(other) and self._value == other._value
+
+    def __ne__(self, other):
+        return not self == other
+
+    def __lt__(self, other):
+        if not isinstance(other, FeatureValueType):
+            raise_unorderable_types("<", self, other)
+        return self._value < other._value
+
+    def __hash__(self):
+        return hash(self._value)
+
+
+class DependencyGrammar:
+    """
+    A dependency grammar.  A DependencyGrammar consists of a set of
+    productions.  Each production specifies a head/modifier relationship
+    between a pair of words.
+    """
+
+    def __init__(self, productions):
+        """
+        Create a new dependency grammar, from the set of ``Productions``.
+
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        """
+        self._productions = productions
+
+    @classmethod
+    def fromstring(cls, input):
+        productions = []
+        for linenum, line in enumerate(input.split("\n")):
+            line = line.strip()
+            if line.startswith("#") or line == "":
+                continue
+            try:
+                productions += _read_dependency_production(line)
+            except ValueError as e:
+                raise ValueError(f"Unable to parse line {linenum}: {line}") from e
+        if len(productions) == 0:
+            raise ValueError("No productions found!")
+        return cls(productions)
+
+    def contains(self, head, mod):
+        """
+        :param head: A head word.
+        :type head: str
+        :param mod: A mod word, to test as a modifier of 'head'.
+        :type mod: str
+
+        :return: true if this ``DependencyGrammar`` contains a
+            ``DependencyProduction`` mapping 'head' to 'mod'.
+        :rtype: bool
+        """
+        for production in self._productions:
+            for possibleMod in production._rhs:
+                if production._lhs == head and possibleMod == mod:
+                    return True
+        return False
+
+    def __contains__(self, head_mod):
+        """
+        Return True if this ``DependencyGrammar`` contains a
+        ``DependencyProduction`` mapping 'head' to 'mod'.
+
+        :param head_mod: A tuple of a head word and a mod word,
+            to test as a modifier of 'head'.
+        :type head: Tuple[str, str]
+        :rtype: bool
+        """
+        try:
+            head, mod = head_mod
+        except ValueError as e:
+            raise ValueError(
+                "Must use a tuple of strings, e.g. `('price', 'of') in grammar`"
+            ) from e
+        return self.contains(head, mod)
+
+    #   # should be rewritten, the set comp won't work in all comparisons
+    # def contains_exactly(self, head, modlist):
+    #   for production in self._productions:
+    #       if(len(production._rhs) == len(modlist)):
+    #           if(production._lhs == head):
+    #               set1 = Set(production._rhs)
+    #               set2 = Set(modlist)
+    #               if(set1 == set2):
+    #                   return True
+    #   return False
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``DependencyGrammar``
+
+        :rtype: str
+        """
+        str = "Dependency grammar with %d productions" % len(self._productions)
+        for production in self._productions:
+            str += "\n  %s" % production
+        return str
+
+    def __repr__(self):
+        """
+        Return a concise string representation of the ``DependencyGrammar``
+        """
+        return "Dependency grammar with %d productions" % len(self._productions)
+
+
+class ProbabilisticDependencyGrammar:
+    """ """
+
+    def __init__(self, productions, events, tags):
+        self._productions = productions
+        self._events = events
+        self._tags = tags
+
+    def contains(self, head, mod):
+        """
+        Return True if this ``DependencyGrammar`` contains a
+        ``DependencyProduction`` mapping 'head' to 'mod'.
+
+        :param head: A head word.
+        :type head: str
+        :param mod: A mod word, to test as a modifier of 'head'.
+        :type mod: str
+        :rtype: bool
+        """
+        for production in self._productions:
+            for possibleMod in production._rhs:
+                if production._lhs == head and possibleMod == mod:
+                    return True
+        return False
+
+    def __str__(self):
+        """
+        Return a verbose string representation of the ``ProbabilisticDependencyGrammar``
+
+        :rtype: str
+        """
+        str = "Statistical dependency grammar with %d productions" % len(
+            self._productions
+        )
+        for production in self._productions:
+            str += "\n  %s" % production
+        str += "\nEvents:"
+        for event in self._events:
+            str += "\n  %d:%s" % (self._events[event], event)
+        str += "\nTags:"
+        for tag_word in self._tags:
+            str += f"\n {tag_word}:\t({self._tags[tag_word]})"
+        return str
+
+    def __repr__(self):
+        """
+        Return a concise string representation of the ``ProbabilisticDependencyGrammar``
+        """
+        return "Statistical Dependency grammar with %d productions" % len(
+            self._productions
+        )
+
+
+class PCFG(CFG):
+    """
+    A probabilistic context-free grammar.  A PCFG consists of a
+    start state and a set of productions with probabilities.  The set of
+    terminals and nonterminals is implicitly specified by the productions.
+
+    PCFG productions use the ``ProbabilisticProduction`` class.
+    ``PCFGs`` impose the constraint that the set of productions with
+    any given left-hand-side must have probabilities that sum to 1
+    (allowing for a small margin of error).
+
+    If you need efficient key-based access to productions, you can use
+    a subclass to implement it.
+
+    :type EPSILON: float
+    :cvar EPSILON: The acceptable margin of error for checking that
+        productions with a given left-hand side have probabilities
+        that sum to 1.
+    """
+
+    EPSILON = 0.01
+
+    def __init__(self, start, productions, calculate_leftcorners=True):
+        """
+        Create a new context-free grammar, from the given start state
+        and set of ``ProbabilisticProductions``.
+
+        :param start: The start symbol
+        :type start: Nonterminal
+        :param productions: The list of productions that defines the grammar
+        :type productions: list(Production)
+        :raise ValueError: if the set of productions with any left-hand-side
+            do not have probabilities that sum to a value within
+            EPSILON of 1.
+        :param calculate_leftcorners: False if we don't want to calculate the
+            leftcorner relation. In that case, some optimized chart parsers won't work.
+        :type calculate_leftcorners: bool
+        """
+        CFG.__init__(self, start, productions, calculate_leftcorners)
+
+        # Make sure that the probabilities sum to one.
+        probs = {}
+        for production in productions:
+            probs[production.lhs()] = probs.get(production.lhs(), 0) + production.prob()
+        for (lhs, p) in probs.items():
+            if not ((1 - PCFG.EPSILON) < p < (1 + PCFG.EPSILON)):
+                raise ValueError("Productions for %r do not sum to 1" % lhs)
+
+    @classmethod
+    def fromstring(cls, input, encoding=None):
+        """
+        Return a probabilistic context-free grammar corresponding to the
+        input string(s).
+
+        :param input: a grammar, either in the form of a string or else
+             as a list of strings.
+        """
+        start, productions = read_grammar(
+            input, standard_nonterm_parser, probabilistic=True, encoding=encoding
+        )
+        return cls(start, productions)
+
+
+#################################################################
+# Inducing Grammars
+#################################################################
+
+# Contributed by Nathan Bodenstab <[email protected]>
+
+
+def induce_pcfg(start, productions):
+    r"""
+    Induce a PCFG grammar from a list of productions.
+
+    The probability of a production A -> B C in a PCFG is:
+
+    |                count(A -> B C)
+    |  P(B, C | A) = ---------------       where \* is any right hand side
+    |                 count(A -> \*)
+
+    :param start: The start symbol
+    :type start: Nonterminal
+    :param productions: The list of productions that defines the grammar
+    :type productions: list(Production)
+    """
+    # Production count: the number of times a given production occurs
+    pcount = {}
+
+    # LHS-count: counts the number of times a given lhs occurs
+    lcount = {}
+
+    for prod in productions:
+        lcount[prod.lhs()] = lcount.get(prod.lhs(), 0) + 1
+        pcount[prod] = pcount.get(prod, 0) + 1
+
+    prods = [
+        ProbabilisticProduction(p.lhs(), p.rhs(), prob=pcount[p] / lcount[p.lhs()])
+        for p in pcount
+    ]
+    return PCFG(start, prods)
+
+
+#################################################################
+# Helper functions for reading productions
+#################################################################
+
+
+def _read_cfg_production(input):
+    """
+    Return a list of context-free ``Productions``.
+    """
+    return _read_production(input, standard_nonterm_parser)
+
+
+def _read_pcfg_production(input):
+    """
+    Return a list of PCFG ``ProbabilisticProductions``.
+    """
+    return _read_production(input, standard_nonterm_parser, probabilistic=True)
+
+
+def _read_fcfg_production(input, fstruct_reader):
+    """
+    Return a list of feature-based ``Productions``.
+    """
+    return _read_production(input, fstruct_reader)
+
+
+# Parsing generic grammars
+
+_ARROW_RE = re.compile(r"\s* -> \s*", re.VERBOSE)
+_PROBABILITY_RE = re.compile(r"( \[ [\d\.]+ \] ) \s*", re.VERBOSE)
+_TERMINAL_RE = re.compile(r'( "[^"]*" | \'[^\']*\' ) \s*', re.VERBOSE)
+_DISJUNCTION_RE = re.compile(r"\| \s*", re.VERBOSE)
+
+
+def _read_production(line, nonterm_parser, probabilistic=False):
+    """
+    Parse a grammar rule, given as a string, and return
+    a list of productions.
+    """
+    pos = 0
+
+    # Parse the left-hand side.
+    lhs, pos = nonterm_parser(line, pos)
+
+    # Skip over the arrow.
+    m = _ARROW_RE.match(line, pos)
+    if not m:
+        raise ValueError("Expected an arrow")
+    pos = m.end()
+
+    # Parse the right hand side.
+    probabilities = [0.0]
+    rhsides = [[]]
+    while pos < len(line):
+        # Probability.
+        m = _PROBABILITY_RE.match(line, pos)
+        if probabilistic and m:
+            pos = m.end()
+            probabilities[-1] = float(m.group(1)[1:-1])
+            if probabilities[-1] > 1.0:
+                raise ValueError(
+                    "Production probability %f, "
+                    "should not be greater than 1.0" % (probabilities[-1],)
+                )
+
+        # String -- add terminal.
+        elif line[pos] in "'\"":
+            m = _TERMINAL_RE.match(line, pos)
+            if not m:
+                raise ValueError("Unterminated string")
+            rhsides[-1].append(m.group(1)[1:-1])
+            pos = m.end()
+
+        # Vertical bar -- start new rhside.
+        elif line[pos] == "|":
+            m = _DISJUNCTION_RE.match(line, pos)
+            probabilities.append(0.0)
+            rhsides.append([])
+            pos = m.end()
+
+        # Anything else -- nonterminal.
+        else:
+            nonterm, pos = nonterm_parser(line, pos)
+            rhsides[-1].append(nonterm)
+
+    if probabilistic:
+        return [
+            ProbabilisticProduction(lhs, rhs, prob=probability)
+            for (rhs, probability) in zip(rhsides, probabilities)
+        ]
+    else:
+        return [Production(lhs, rhs) for rhs in rhsides]
+
+
+#################################################################
+# Reading Phrase Structure Grammars
+#################################################################
+
+
+def read_grammar(input, nonterm_parser, probabilistic=False, encoding=None):
+    """
+    Return a pair consisting of a starting category and a list of
+    ``Productions``.
+
+    :param input: a grammar, either in the form of a string or else
+        as a list of strings.
+    :param nonterm_parser: a function for parsing nonterminals.
+        It should take a ``(string, position)`` as argument and
+        return a ``(nonterminal, position)`` as result.
+    :param probabilistic: are the grammar rules probabilistic?
+    :type probabilistic: bool
+    :param encoding: the encoding of the grammar, if it is a binary string
+    :type encoding: str
+    """
+    if encoding is not None:
+        input = input.decode(encoding)
+    if isinstance(input, str):
+        lines = input.split("\n")
+    else:
+        lines = input
+
+    start = None
+    productions = []
+    continue_line = ""
+    for linenum, line in enumerate(lines):
+        line = continue_line + line.strip()
+        if line.startswith("#") or line == "":
+            continue
+        if line.endswith("\\"):
+            continue_line = line[:-1].rstrip() + " "
+            continue
+        continue_line = ""
+        try:
+            if line[0] == "%":
+                directive, args = line[1:].split(None, 1)
+                if directive == "start":
+                    start, pos = nonterm_parser(args, 0)
+                    if pos != len(args):
+                        raise ValueError("Bad argument to start directive")
+                else:
+                    raise ValueError("Bad directive")
+            else:
+                # expand out the disjunctions on the RHS
+                productions += _read_production(line, nonterm_parser, probabilistic)
+        except ValueError as e:
+            raise ValueError(f"Unable to parse line {linenum + 1}: {line}\n{e}") from e
+
+    if not productions:
+        raise ValueError("No productions found!")
+    if not start:
+        start = productions[0].lhs()
+    return (start, productions)
+
+
+_STANDARD_NONTERM_RE = re.compile(r"( [\w/][\w/^<>-]* ) \s*", re.VERBOSE)
+
+
+def standard_nonterm_parser(string, pos):
+    m = _STANDARD_NONTERM_RE.match(string, pos)
+    if not m:
+        raise ValueError("Expected a nonterminal, found: " + string[pos:])
+    return (Nonterminal(m.group(1)), m.end())
+
+
+#################################################################
+# Reading Dependency Grammars
+#################################################################
+
+_READ_DG_RE = re.compile(
+    r"""^\s*                # leading whitespace
+                              ('[^']+')\s*        # single-quoted lhs
+                              (?:[-=]+>)\s*        # arrow
+                              (?:(                 # rhs:
+                                   "[^"]+"         # doubled-quoted terminal
+                                 | '[^']+'         # single-quoted terminal
+                                 | \|              # disjunction
+                                 )
+                                 \s*)              # trailing space
+                                 *$""",  # zero or more copies
+    re.VERBOSE,
+)
+_SPLIT_DG_RE = re.compile(r"""('[^']'|[-=]+>|"[^"]+"|'[^']+'|\|)""")
+
+
+def _read_dependency_production(s):
+    if not _READ_DG_RE.match(s):
+        raise ValueError("Bad production string")
+    pieces = _SPLIT_DG_RE.split(s)
+    pieces = [p for i, p in enumerate(pieces) if i % 2 == 1]
+    lhside = pieces[0].strip("'\"")
+    rhsides = [[]]
+    for piece in pieces[2:]:
+        if piece == "|":
+            rhsides.append([])
+        else:
+            rhsides[-1].append(piece.strip("'\""))
+    return [DependencyProduction(lhside, rhside) for rhside in rhsides]
+
+
+#################################################################
+# Demonstration
+#################################################################
+
+
+def cfg_demo():
+    """
+    A demonstration showing how ``CFGs`` can be created and used.
+    """
+
+    from nltk import CFG, Production, nonterminals
+
+    # Create some nonterminals
+    S, NP, VP, PP = nonterminals("S, NP, VP, PP")
+    N, V, P, Det = nonterminals("N, V, P, Det")
+    VP_slash_NP = VP / NP
+
+    print("Some nonterminals:", [S, NP, VP, PP, N, V, P, Det, VP / NP])
+    print("    S.symbol() =>", repr(S.symbol()))
+    print()
+
+    print(Production(S, [NP]))
+
+    # Create some Grammar Productions
+    grammar = CFG.fromstring(
+        """
+      S -> NP VP
+      PP -> P NP
+      NP -> Det N | NP PP
+      VP -> V NP | VP PP
+      Det -> 'a' | 'the'
+      N -> 'dog' | 'cat'
+      V -> 'chased' | 'sat'
+      P -> 'on' | 'in'
+    """
+    )
+
+    print("A Grammar:", repr(grammar))
+    print("    grammar.start()       =>", repr(grammar.start()))
+    print("    grammar.productions() =>", end=" ")
+    # Use string.replace(...) is to line-wrap the output.
+    print(repr(grammar.productions()).replace(",", ",\n" + " " * 25))
+    print()
+
+
+def pcfg_demo():
+    """
+    A demonstration showing how a ``PCFG`` can be created and used.
+    """
+
+    from nltk import induce_pcfg, treetransforms
+    from nltk.corpus import treebank
+    from nltk.parse import pchart
+
+    toy_pcfg1 = PCFG.fromstring(
+        """
+        S -> NP VP [1.0]
+        NP -> Det N [0.5] | NP PP [0.25] | 'John' [0.1] | 'I' [0.15]
+        Det -> 'the' [0.8] | 'my' [0.2]
+        N -> 'man' [0.5] | 'telescope' [0.5]
+        VP -> VP PP [0.1] | V NP [0.7] | V [0.2]
+        V -> 'ate' [0.35] | 'saw' [0.65]
+        PP -> P NP [1.0]
+        P -> 'with' [0.61] | 'under' [0.39]
+        """
+    )
+
+    toy_pcfg2 = PCFG.fromstring(
+        """
+        S    -> NP VP         [1.0]
+        VP   -> V NP          [.59]
+        VP   -> V             [.40]
+        VP   -> VP PP         [.01]
+        NP   -> Det N         [.41]
+        NP   -> Name          [.28]
+        NP   -> NP PP         [.31]
+        PP   -> P NP          [1.0]
+        V    -> 'saw'         [.21]
+        V    -> 'ate'         [.51]
+        V    -> 'ran'         [.28]
+        N    -> 'boy'         [.11]
+        N    -> 'cookie'      [.12]
+        N    -> 'table'       [.13]
+        N    -> 'telescope'   [.14]
+        N    -> 'hill'        [.5]
+        Name -> 'Jack'        [.52]
+        Name -> 'Bob'         [.48]
+        P    -> 'with'        [.61]
+        P    -> 'under'       [.39]
+        Det  -> 'the'         [.41]
+        Det  -> 'a'           [.31]
+        Det  -> 'my'          [.28]
+        """
+    )
+
+    pcfg_prods = toy_pcfg1.productions()
+
+    pcfg_prod = pcfg_prods[2]
+    print("A PCFG production:", repr(pcfg_prod))
+    print("    pcfg_prod.lhs()  =>", repr(pcfg_prod.lhs()))
+    print("    pcfg_prod.rhs()  =>", repr(pcfg_prod.rhs()))
+    print("    pcfg_prod.prob() =>", repr(pcfg_prod.prob()))
+    print()
+
+    grammar = toy_pcfg2
+    print("A PCFG grammar:", repr(grammar))
+    print("    grammar.start()       =>", repr(grammar.start()))
+    print("    grammar.productions() =>", end=" ")
+    # Use .replace(...) is to line-wrap the output.
+    print(repr(grammar.productions()).replace(",", ",\n" + " " * 26))
+    print()
+
+    # extract productions from three trees and induce the PCFG
+    print("Induce PCFG grammar from treebank data:")
+
+    productions = []
+    item = treebank._fileids[0]
+    for tree in treebank.parsed_sents(item)[:3]:
+        # perform optional tree transformations, e.g.:
+        tree.collapse_unary(collapsePOS=False)
+        tree.chomsky_normal_form(horzMarkov=2)
+
+        productions += tree.productions()
+
+    S = Nonterminal("S")
+    grammar = induce_pcfg(S, productions)
+    print(grammar)
+    print()
+
+    print("Parse sentence using induced grammar:")
+
+    parser = pchart.InsideChartParser(grammar)
+    parser.trace(3)
+
+    # doesn't work as tokens are different:
+    # sent = treebank.tokenized('wsj_0001.mrg')[0]
+
+    sent = treebank.parsed_sents(item)[0].leaves()
+    print(sent)
+    for parse in parser.parse(sent):
+        print(parse)
+
+
+def fcfg_demo():
+    import nltk.data
+
+    g = nltk.data.load("grammars/book_grammars/feat0.fcfg")
+    print(g)
+    print()
+
+
+def dg_demo():
+    """
+    A demonstration showing the creation and inspection of a
+    ``DependencyGrammar``.
+    """
+    grammar = DependencyGrammar.fromstring(
+        """
+    'scratch' -> 'cats' | 'walls'
+    'walls' -> 'the'
+    'cats' -> 'the'
+    """
+    )
+    print(grammar)
+
+
+def sdg_demo():
+    """
+    A demonstration of how to read a string representation of
+    a CoNLL format dependency tree.
+    """
+    from nltk.parse import DependencyGraph
+
+    dg = DependencyGraph(
+        """
+    1   Ze                ze                Pron  Pron  per|3|evofmv|nom                 2   su      _  _
+    2   had               heb               V     V     trans|ovt|1of2of3|ev             0   ROOT    _  _
+    3   met               met               Prep  Prep  voor                             8   mod     _  _
+    4   haar              haar              Pron  Pron  bez|3|ev|neut|attr               5   det     _  _
+    5   moeder            moeder            N     N     soort|ev|neut                    3   obj1    _  _
+    6   kunnen            kan               V     V     hulp|ott|1of2of3|mv              2   vc      _  _
+    7   gaan              ga                V     V     hulp|inf                         6   vc      _  _
+    8   winkelen          winkel            V     V     intrans|inf                      11  cnj     _  _
+    9   ,                 ,                 Punc  Punc  komma                            8   punct   _  _
+    10  zwemmen           zwem              V     V     intrans|inf                      11  cnj     _  _
+    11  of                of                Conj  Conj  neven                            7   vc      _  _
+    12  terrassen         terras            N     N     soort|mv|neut                    11  cnj     _  _
+    13  .                 .                 Punc  Punc  punt                             12  punct   _  _
+    """
+    )
+    tree = dg.tree()
+    print(tree.pprint())
+
+
+def demo():
+    cfg_demo()
+    pcfg_demo()
+    fcfg_demo()
+    dg_demo()
+    sdg_demo()
+
+
+if __name__ == "__main__":
+    demo()
+
+__all__ = [
+    "Nonterminal",
+    "nonterminals",
+    "CFG",
+    "Production",
+    "PCFG",
+    "ProbabilisticProduction",
+    "DependencyGrammar",
+    "DependencyProduction",
+    "ProbabilisticDependencyGrammar",
+    "induce_pcfg",
+    "read_grammar",
+]

llmeval-env/lib/python3.10/site-packages/nltk/help.py

@@ -0,0 +1,64 @@
+# Natural Language Toolkit (NLTK) Help
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Authors: Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Provide structured access to documentation.
+"""
+
+import re
+from textwrap import wrap
+
+from nltk.data import load
+
+
+def brown_tagset(tagpattern=None):
+    _format_tagset("brown_tagset", tagpattern)
+
+
+def claws5_tagset(tagpattern=None):
+    _format_tagset("claws5_tagset", tagpattern)
+
+
+def upenn_tagset(tagpattern=None):
+    _format_tagset("upenn_tagset", tagpattern)
+
+
+#####################################################################
+# UTILITIES
+#####################################################################
+
+
+def _print_entries(tags, tagdict):
+    for tag in tags:
+        entry = tagdict[tag]
+        defn = [tag + ": " + entry[0]]
+        examples = wrap(
+            entry[1], width=75, initial_indent="    ", subsequent_indent="    "
+        )
+        print("\n".join(defn + examples))
+
+
+def _format_tagset(tagset, tagpattern=None):
+    tagdict = load("help/tagsets/" + tagset + ".pickle")
+    if not tagpattern:
+        _print_entries(sorted(tagdict), tagdict)
+    elif tagpattern in tagdict:
+        _print_entries([tagpattern], tagdict)
+    else:
+        tagpattern = re.compile(tagpattern)
+        tags = [tag for tag in sorted(tagdict) if tagpattern.match(tag)]
+        if tags:
+            _print_entries(tags, tagdict)
+        else:
+            print("No matching tags found.")
+
+
+if __name__ == "__main__":
+    brown_tagset(r"NN.*")
+    upenn_tagset(r".*\$")
+    claws5_tagset("UNDEFINED")
+    brown_tagset(r"NN")

llmeval-env/lib/python3.10/site-packages/nltk/internals.py

@@ -0,0 +1,1123 @@
+# Natural Language Toolkit: Internal utility functions
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+#         Edward Loper <[email protected]>
+#         Nitin Madnani <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import fnmatch
+import locale
+import os
+import re
+import stat
+import subprocess
+import sys
+import textwrap
+import types
+import warnings
+from xml.etree import ElementTree
+
+##########################################################################
+# Java Via Command-Line
+##########################################################################
+
+_java_bin = None
+_java_options = []
+# [xx] add classpath option to config_java?
+def config_java(bin=None, options=None, verbose=False):
+    """
+    Configure nltk's java interface, by letting nltk know where it can
+    find the Java binary, and what extra options (if any) should be
+    passed to Java when it is run.
+
+    :param bin: The full path to the Java binary.  If not specified,
+        then nltk will search the system for a Java binary; and if
+        one is not found, it will raise a ``LookupError`` exception.
+    :type bin: str
+    :param options: A list of options that should be passed to the
+        Java binary when it is called.  A common value is
+        ``'-Xmx512m'``, which tells Java binary to increase
+        the maximum heap size to 512 megabytes.  If no options are
+        specified, then do not modify the options list.
+    :type options: list(str)
+    """
+    global _java_bin, _java_options
+    _java_bin = find_binary(
+        "java",
+        bin,
+        env_vars=["JAVAHOME", "JAVA_HOME"],
+        verbose=verbose,
+        binary_names=["java.exe"],
+    )
+
+    if options is not None:
+        if isinstance(options, str):
+            options = options.split()
+        _java_options = list(options)
+
+
+def java(cmd, classpath=None, stdin=None, stdout=None, stderr=None, blocking=True):
+    """
+    Execute the given java command, by opening a subprocess that calls
+    Java.  If java has not yet been configured, it will be configured
+    by calling ``config_java()`` with no arguments.
+
+    :param cmd: The java command that should be called, formatted as
+        a list of strings.  Typically, the first string will be the name
+        of the java class; and the remaining strings will be arguments
+        for that java class.
+    :type cmd: list(str)
+
+    :param classpath: A ``':'`` separated list of directories, JAR
+        archives, and ZIP archives to search for class files.
+    :type classpath: str
+
+    :param stdin: Specify the executed program's
+        standard input file handles, respectively.  Valid values are ``subprocess.PIPE``,
+        an existing file descriptor (a positive integer), an existing
+        file object, 'pipe', 'stdout', 'devnull' and None.  ``subprocess.PIPE`` indicates that a
+        new pipe to the child should be created.  With None, no
+        redirection will occur; the child's file handles will be
+        inherited from the parent.  Additionally, stderr can be
+        ``subprocess.STDOUT``, which indicates that the stderr data
+        from the applications should be captured into the same file
+        handle as for stdout.
+
+    :param stdout: Specify the executed program's standard output file
+        handle. See ``stdin`` for valid values.
+
+    :param stderr: Specify the executed program's standard error file
+        handle. See ``stdin`` for valid values.
+
+
+    :param blocking: If ``false``, then return immediately after
+        spawning the subprocess.  In this case, the return value is
+        the ``Popen`` object, and not a ``(stdout, stderr)`` tuple.
+
+    :return: If ``blocking=True``, then return a tuple ``(stdout,
+        stderr)``, containing the stdout and stderr outputs generated
+        by the java command if the ``stdout`` and ``stderr`` parameters
+        were set to ``subprocess.PIPE``; or None otherwise.  If
+        ``blocking=False``, then return a ``subprocess.Popen`` object.
+
+    :raise OSError: If the java command returns a nonzero return code.
+    """
+
+    subprocess_output_dict = {
+        "pipe": subprocess.PIPE,
+        "stdout": subprocess.STDOUT,
+        "devnull": subprocess.DEVNULL,
+    }
+
+    stdin = subprocess_output_dict.get(stdin, stdin)
+    stdout = subprocess_output_dict.get(stdout, stdout)
+    stderr = subprocess_output_dict.get(stderr, stderr)
+
+    if isinstance(cmd, str):
+        raise TypeError("cmd should be a list of strings")
+
+    # Make sure we know where a java binary is.
+    if _java_bin is None:
+        config_java()
+
+    # Set up the classpath.
+    if isinstance(classpath, str):
+        classpaths = [classpath]
+    else:
+        classpaths = list(classpath)
+    classpath = os.path.pathsep.join(classpaths)
+
+    # Construct the full command string.
+    cmd = list(cmd)
+    cmd = ["-cp", classpath] + cmd
+    cmd = [_java_bin] + _java_options + cmd
+
+    # Call java via a subprocess
+    p = subprocess.Popen(cmd, stdin=stdin, stdout=stdout, stderr=stderr)
+    if not blocking:
+        return p
+    (stdout, stderr) = p.communicate()
+
+    # Check the return code.
+    if p.returncode != 0:
+        print(_decode_stdoutdata(stderr))
+        raise OSError("Java command failed : " + str(cmd))
+
+    return (stdout, stderr)
+
+
+######################################################################
+# Parsing
+######################################################################
+
+
+class ReadError(ValueError):
+    """
+    Exception raised by read_* functions when they fail.
+    :param position: The index in the input string where an error occurred.
+    :param expected: What was expected when an error occurred.
+    """
+
+    def __init__(self, expected, position):
+        ValueError.__init__(self, expected, position)
+        self.expected = expected
+        self.position = position
+
+    def __str__(self):
+        return f"Expected {self.expected} at {self.position}"
+
+
+_STRING_START_RE = re.compile(r"[uU]?[rR]?(\"\"\"|\'\'\'|\"|\')")
+
+
+def read_str(s, start_position):
+    """
+    If a Python string literal begins at the specified position in the
+    given string, then return a tuple ``(val, end_position)``
+    containing the value of the string literal and the position where
+    it ends.  Otherwise, raise a ``ReadError``.
+
+    :param s: A string that will be checked to see if within which a
+        Python string literal exists.
+    :type s: str
+
+    :param start_position: The specified beginning position of the string ``s``
+        to begin regex matching.
+    :type start_position: int
+
+    :return: A tuple containing the matched string literal evaluated as a
+        string and the end position of the string literal.
+    :rtype: tuple(str, int)
+
+    :raise ReadError: If the ``_STRING_START_RE`` regex doesn't return a
+        match in ``s`` at ``start_position``, i.e., open quote. If the
+        ``_STRING_END_RE`` regex doesn't return a match in ``s`` at the
+        end of the first match, i.e., close quote.
+    :raise ValueError: If an invalid string (i.e., contains an invalid
+        escape sequence) is passed into the ``eval``.
+
+    :Example:
+
+    >>> from nltk.internals import read_str
+    >>> read_str('"Hello", World!', 0)
+    ('Hello', 7)
+
+    """
+    # Read the open quote, and any modifiers.
+    m = _STRING_START_RE.match(s, start_position)
+    if not m:
+        raise ReadError("open quote", start_position)
+    quotemark = m.group(1)
+
+    # Find the close quote.
+    _STRING_END_RE = re.compile(r"\\|%s" % quotemark)
+    position = m.end()
+    while True:
+        match = _STRING_END_RE.search(s, position)
+        if not match:
+            raise ReadError("close quote", position)
+        if match.group(0) == "\\":
+            position = match.end() + 1
+        else:
+            break
+
+    # Process it, using eval.  Strings with invalid escape sequences
+    # might raise ValueError.
+    try:
+        return eval(s[start_position : match.end()]), match.end()
+    except ValueError as e:
+        raise ReadError("valid escape sequence", start_position) from e
+
+
+_READ_INT_RE = re.compile(r"-?\d+")
+
+
+def read_int(s, start_position):
+    """
+    If an integer begins at the specified position in the given
+    string, then return a tuple ``(val, end_position)`` containing the
+    value of the integer and the position where it ends.  Otherwise,
+    raise a ``ReadError``.
+
+    :param s: A string that will be checked to see if within which a
+        Python integer exists.
+    :type s: str
+
+    :param start_position: The specified beginning position of the string ``s``
+        to begin regex matching.
+    :type start_position: int
+
+    :return: A tuple containing the matched integer casted to an int,
+        and the end position of the int in ``s``.
+    :rtype: tuple(int, int)
+
+    :raise ReadError: If the ``_READ_INT_RE`` regex doesn't return a
+        match in ``s`` at ``start_position``.
+
+    :Example:
+
+    >>> from nltk.internals import read_int
+    >>> read_int('42 is the answer', 0)
+    (42, 2)
+
+    """
+    m = _READ_INT_RE.match(s, start_position)
+    if not m:
+        raise ReadError("integer", start_position)
+    return int(m.group()), m.end()
+
+
+_READ_NUMBER_VALUE = re.compile(r"-?(\d*)([.]?\d*)?")
+
+
+def read_number(s, start_position):
+    """
+    If an integer or float begins at the specified position in the
+    given string, then return a tuple ``(val, end_position)``
+    containing the value of the number and the position where it ends.
+    Otherwise, raise a ``ReadError``.
+
+    :param s: A string that will be checked to see if within which a
+        Python number exists.
+    :type s: str
+
+    :param start_position: The specified beginning position of the string ``s``
+        to begin regex matching.
+    :type start_position: int
+
+    :return: A tuple containing the matched number casted to a ``float``,
+        and the end position of the number in ``s``.
+    :rtype: tuple(float, int)
+
+    :raise ReadError: If the ``_READ_NUMBER_VALUE`` regex doesn't return a
+        match in ``s`` at ``start_position``.
+
+    :Example:
+
+    >>> from nltk.internals import read_number
+    >>> read_number('Pi is 3.14159', 6)
+    (3.14159, 13)
+
+    """
+    m = _READ_NUMBER_VALUE.match(s, start_position)
+    if not m or not (m.group(1) or m.group(2)):
+        raise ReadError("number", start_position)
+    if m.group(2):
+        return float(m.group()), m.end()
+    else:
+        return int(m.group()), m.end()
+
+
+######################################################################
+# Check if a method has been overridden
+######################################################################
+
+
+def overridden(method):
+    """
+    :return: True if ``method`` overrides some method with the same
+        name in a base class.  This is typically used when defining
+        abstract base classes or interfaces, to allow subclasses to define
+        either of two related methods:
+
+        >>> class EaterI:
+        ...     '''Subclass must define eat() or batch_eat().'''
+        ...     def eat(self, food):
+        ...         if overridden(self.batch_eat):
+        ...             return self.batch_eat([food])[0]
+        ...         else:
+        ...             raise NotImplementedError()
+        ...     def batch_eat(self, foods):
+        ...         return [self.eat(food) for food in foods]
+
+    :type method: instance method
+    """
+    if isinstance(method, types.MethodType) and method.__self__.__class__ is not None:
+        name = method.__name__
+        funcs = [
+            cls.__dict__[name]
+            for cls in _mro(method.__self__.__class__)
+            if name in cls.__dict__
+        ]
+        return len(funcs) > 1
+    else:
+        raise TypeError("Expected an instance method.")
+
+
+def _mro(cls):
+    """
+    Return the method resolution order for ``cls`` -- i.e., a list
+    containing ``cls`` and all its base classes, in the order in which
+    they would be checked by ``getattr``.  For new-style classes, this
+    is just cls.__mro__.  For classic classes, this can be obtained by
+    a depth-first left-to-right traversal of ``__bases__``.
+    """
+    if isinstance(cls, type):
+        return cls.__mro__
+    else:
+        mro = [cls]
+        for base in cls.__bases__:
+            mro.extend(_mro(base))
+        return mro
+
+
+######################################################################
+# Deprecation decorator & base class
+######################################################################
+# [xx] dedent msg first if it comes from  a docstring.
+
+
+def _add_epytext_field(obj, field, message):
+    """Add an epytext @field to a given object's docstring."""
+    indent = ""
+    # If we already have a docstring, then add a blank line to separate
+    # it from the new field, and check its indentation.
+    if obj.__doc__:
+        obj.__doc__ = obj.__doc__.rstrip() + "\n\n"
+        indents = re.findall(r"(?<=\n)[ ]+(?!\s)", obj.__doc__.expandtabs())
+        if indents:
+            indent = min(indents)
+    # If we don't have a docstring, add an empty one.
+    else:
+        obj.__doc__ = ""
+
+    obj.__doc__ += textwrap.fill(
+        f"@{field}: {message}",
+        initial_indent=indent,
+        subsequent_indent=indent + "    ",
+    )
+
+
+def deprecated(message):
+    """
+    A decorator used to mark functions as deprecated.  This will cause
+    a warning to be printed the when the function is used.  Usage:
+
+        >>> from nltk.internals import deprecated
+        >>> @deprecated('Use foo() instead')
+        ... def bar(x):
+        ...     print(x/10)
+
+    """
+
+    def decorator(func):
+        msg = f"Function {func.__name__}() has been deprecated.  {message}"
+        msg = "\n" + textwrap.fill(msg, initial_indent="  ", subsequent_indent="  ")
+
+        def newFunc(*args, **kwargs):
+            warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+            return func(*args, **kwargs)
+
+        # Copy the old function's name, docstring, & dict
+        newFunc.__dict__.update(func.__dict__)
+        newFunc.__name__ = func.__name__
+        newFunc.__doc__ = func.__doc__
+        newFunc.__deprecated__ = True
+        # Add a @deprecated field to the docstring.
+        _add_epytext_field(newFunc, "deprecated", message)
+        return newFunc
+
+    return decorator
+
+
+class Deprecated:
+    """
+    A base class used to mark deprecated classes.  A typical usage is to
+    alert users that the name of a class has changed:
+
+        >>> from nltk.internals import Deprecated
+        >>> class NewClassName:
+        ...     pass # All logic goes here.
+        ...
+        >>> class OldClassName(Deprecated, NewClassName):
+        ...     "Use NewClassName instead."
+
+    The docstring of the deprecated class will be used in the
+    deprecation warning message.
+    """
+
+    def __new__(cls, *args, **kwargs):
+        # Figure out which class is the deprecated one.
+        dep_cls = None
+        for base in _mro(cls):
+            if Deprecated in base.__bases__:
+                dep_cls = base
+                break
+        assert dep_cls, "Unable to determine which base is deprecated."
+
+        # Construct an appropriate warning.
+        doc = dep_cls.__doc__ or "".strip()
+        # If there's a @deprecated field, strip off the field marker.
+        doc = re.sub(r"\A\s*@deprecated:", r"", doc)
+        # Strip off any indentation.
+        doc = re.sub(r"(?m)^\s*", "", doc)
+        # Construct a 'name' string.
+        name = "Class %s" % dep_cls.__name__
+        if cls != dep_cls:
+            name += " (base class for %s)" % cls.__name__
+        # Put it all together.
+        msg = f"{name} has been deprecated.  {doc}"
+        # Wrap it.
+        msg = "\n" + textwrap.fill(msg, initial_indent="    ", subsequent_indent="    ")
+        warnings.warn(msg, category=DeprecationWarning, stacklevel=2)
+        # Do the actual work of __new__.
+        return object.__new__(cls)
+
+
+##########################################################################
+# COUNTER, FOR UNIQUE NAMING
+##########################################################################
+
+
+class Counter:
+    """
+    A counter that auto-increments each time its value is read.
+    """
+
+    def __init__(self, initial_value=0):
+        self._value = initial_value
+
+    def get(self):
+        self._value += 1
+        return self._value
+
+
+##########################################################################
+# Search for files/binaries
+##########################################################################
+
+
+def find_file_iter(
+    filename,
+    env_vars=(),
+    searchpath=(),
+    file_names=None,
+    url=None,
+    verbose=False,
+    finding_dir=False,
+):
+    """
+    Search for a file to be used by nltk.
+
+    :param filename: The name or path of the file.
+    :param env_vars: A list of environment variable names to check.
+    :param file_names: A list of alternative file names to check.
+    :param searchpath: List of directories to search.
+    :param url: URL presented to user for download help.
+    :param verbose: Whether or not to print path when a file is found.
+    """
+    file_names = [filename] + (file_names or [])
+    assert isinstance(filename, str)
+    assert not isinstance(file_names, str)
+    assert not isinstance(searchpath, str)
+    if isinstance(env_vars, str):
+        env_vars = env_vars.split()
+    yielded = False
+
+    # File exists, no magic
+    for alternative in file_names:
+        path_to_file = os.path.join(filename, alternative)
+        if os.path.isfile(path_to_file):
+            if verbose:
+                print(f"[Found {filename}: {path_to_file}]")
+            yielded = True
+            yield path_to_file
+        # Check the bare alternatives
+        if os.path.isfile(alternative):
+            if verbose:
+                print(f"[Found {filename}: {alternative}]")
+            yielded = True
+            yield alternative
+        # Check if the alternative is inside a 'file' directory
+        path_to_file = os.path.join(filename, "file", alternative)
+        if os.path.isfile(path_to_file):
+            if verbose:
+                print(f"[Found {filename}: {path_to_file}]")
+            yielded = True
+            yield path_to_file
+
+    # Check environment variables
+    for env_var in env_vars:
+        if env_var in os.environ:
+            if finding_dir:  # This is to file a directory instead of file
+                yielded = True
+                yield os.environ[env_var]
+
+            for env_dir in os.environ[env_var].split(os.pathsep):
+                # Check if the environment variable contains a direct path to the bin
+                if os.path.isfile(env_dir):
+                    if verbose:
+                        print(f"[Found {filename}: {env_dir}]")
+                    yielded = True
+                    yield env_dir
+                # Check if the possible bin names exist inside the environment variable directories
+                for alternative in file_names:
+                    path_to_file = os.path.join(env_dir, alternative)
+                    if os.path.isfile(path_to_file):
+                        if verbose:
+                            print(f"[Found {filename}: {path_to_file}]")
+                        yielded = True
+                        yield path_to_file
+                    # Check if the alternative is inside a 'file' directory
+                    # path_to_file = os.path.join(env_dir, 'file', alternative)
+
+                    # Check if the alternative is inside a 'bin' directory
+                    path_to_file = os.path.join(env_dir, "bin", alternative)
+
+                    if os.path.isfile(path_to_file):
+                        if verbose:
+                            print(f"[Found {filename}: {path_to_file}]")
+                        yielded = True
+                        yield path_to_file
+
+    # Check the path list.
+    for directory in searchpath:
+        for alternative in file_names:
+            path_to_file = os.path.join(directory, alternative)
+            if os.path.isfile(path_to_file):
+                yielded = True
+                yield path_to_file
+
+    # If we're on a POSIX system, then try using the 'which' command
+    # to find the file.
+    if os.name == "posix":
+        for alternative in file_names:
+            try:
+                p = subprocess.Popen(
+                    ["which", alternative],
+                    stdout=subprocess.PIPE,
+                    stderr=subprocess.PIPE,
+                )
+                stdout, stderr = p.communicate()
+                path = _decode_stdoutdata(stdout).strip()
+                if path.endswith(alternative) and os.path.exists(path):
+                    if verbose:
+                        print(f"[Found {filename}: {path}]")
+                    yielded = True
+                    yield path
+            except (KeyboardInterrupt, SystemExit, OSError):
+                raise
+            finally:
+                pass
+
+    if not yielded:
+        msg = (
+            "NLTK was unable to find the %s file!"
+            "\nUse software specific "
+            "configuration parameters" % filename
+        )
+        if env_vars:
+            msg += " or set the %s environment variable" % env_vars[0]
+        msg += "."
+        if searchpath:
+            msg += "\n\n  Searched in:"
+            msg += "".join("\n    - %s" % d for d in searchpath)
+        if url:
+            msg += f"\n\n  For more information on {filename}, see:\n    <{url}>"
+        div = "=" * 75
+        raise LookupError(f"\n\n{div}\n{msg}\n{div}")
+
+
+def find_file(
+    filename, env_vars=(), searchpath=(), file_names=None, url=None, verbose=False
+):
+    return next(
+        find_file_iter(filename, env_vars, searchpath, file_names, url, verbose)
+    )
+
+
+def find_dir(
+    filename, env_vars=(), searchpath=(), file_names=None, url=None, verbose=False
+):
+    return next(
+        find_file_iter(
+            filename, env_vars, searchpath, file_names, url, verbose, finding_dir=True
+        )
+    )
+
+
+def find_binary_iter(
+    name,
+    path_to_bin=None,
+    env_vars=(),
+    searchpath=(),
+    binary_names=None,
+    url=None,
+    verbose=False,
+):
+    """
+    Search for a file to be used by nltk.
+
+    :param name: The name or path of the file.
+    :param path_to_bin: The user-supplied binary location (deprecated)
+    :param env_vars: A list of environment variable names to check.
+    :param file_names: A list of alternative file names to check.
+    :param searchpath: List of directories to search.
+    :param url: URL presented to user for download help.
+    :param verbose: Whether or not to print path when a file is found.
+    """
+    yield from find_file_iter(
+        path_to_bin or name, env_vars, searchpath, binary_names, url, verbose
+    )
+
+
+def find_binary(
+    name,
+    path_to_bin=None,
+    env_vars=(),
+    searchpath=(),
+    binary_names=None,
+    url=None,
+    verbose=False,
+):
+    return next(
+        find_binary_iter(
+            name, path_to_bin, env_vars, searchpath, binary_names, url, verbose
+        )
+    )
+
+
+def find_jar_iter(
+    name_pattern,
+    path_to_jar=None,
+    env_vars=(),
+    searchpath=(),
+    url=None,
+    verbose=False,
+    is_regex=False,
+):
+    """
+    Search for a jar that is used by nltk.
+
+    :param name_pattern: The name of the jar file
+    :param path_to_jar: The user-supplied jar location, or None.
+    :param env_vars: A list of environment variable names to check
+                     in addition to the CLASSPATH variable which is
+                     checked by default.
+    :param searchpath: List of directories to search.
+    :param is_regex: Whether name is a regular expression.
+    """
+
+    assert isinstance(name_pattern, str)
+    assert not isinstance(searchpath, str)
+    if isinstance(env_vars, str):
+        env_vars = env_vars.split()
+    yielded = False
+
+    # Make sure we check the CLASSPATH first
+    env_vars = ["CLASSPATH"] + list(env_vars)
+
+    # If an explicit location was given, then check it, and yield it if
+    # it's present; otherwise, complain.
+    if path_to_jar is not None:
+        if os.path.isfile(path_to_jar):
+            yielded = True
+            yield path_to_jar
+        else:
+            raise LookupError(
+                f"Could not find {name_pattern} jar file at {path_to_jar}"
+            )
+
+    # Check environment variables
+    for env_var in env_vars:
+        if env_var in os.environ:
+            if env_var == "CLASSPATH":
+                classpath = os.environ["CLASSPATH"]
+                for cp in classpath.split(os.path.pathsep):
+                    cp = os.path.expanduser(cp)
+                    if os.path.isfile(cp):
+                        filename = os.path.basename(cp)
+                        if (
+                            is_regex
+                            and re.match(name_pattern, filename)
+                            or (not is_regex and filename == name_pattern)
+                        ):
+                            if verbose:
+                                print(f"[Found {name_pattern}: {cp}]")
+                            yielded = True
+                            yield cp
+                    # The case where user put directory containing the jar file in the classpath
+                    if os.path.isdir(cp):
+                        if not is_regex:
+                            if os.path.isfile(os.path.join(cp, name_pattern)):
+                                if verbose:
+                                    print(f"[Found {name_pattern}: {cp}]")
+                                yielded = True
+                                yield os.path.join(cp, name_pattern)
+                        else:
+                            # Look for file using regular expression
+                            for file_name in os.listdir(cp):
+                                if re.match(name_pattern, file_name):
+                                    if verbose:
+                                        print(
+                                            "[Found %s: %s]"
+                                            % (
+                                                name_pattern,
+                                                os.path.join(cp, file_name),
+                                            )
+                                        )
+                                    yielded = True
+                                    yield os.path.join(cp, file_name)
+
+            else:
+                jar_env = os.path.expanduser(os.environ[env_var])
+                jar_iter = (
+                    (
+                        os.path.join(jar_env, path_to_jar)
+                        for path_to_jar in os.listdir(jar_env)
+                    )
+                    if os.path.isdir(jar_env)
+                    else (jar_env,)
+                )
+                for path_to_jar in jar_iter:
+                    if os.path.isfile(path_to_jar):
+                        filename = os.path.basename(path_to_jar)
+                        if (
+                            is_regex
+                            and re.match(name_pattern, filename)
+                            or (not is_regex and filename == name_pattern)
+                        ):
+                            if verbose:
+                                print(f"[Found {name_pattern}: {path_to_jar}]")
+                            yielded = True
+                            yield path_to_jar
+
+    # Check the path list.
+    for directory in searchpath:
+        if is_regex:
+            for filename in os.listdir(directory):
+                path_to_jar = os.path.join(directory, filename)
+                if os.path.isfile(path_to_jar):
+                    if re.match(name_pattern, filename):
+                        if verbose:
+                            print(f"[Found {filename}: {path_to_jar}]")
+                yielded = True
+                yield path_to_jar
+        else:
+            path_to_jar = os.path.join(directory, name_pattern)
+            if os.path.isfile(path_to_jar):
+                if verbose:
+                    print(f"[Found {name_pattern}: {path_to_jar}]")
+                yielded = True
+                yield path_to_jar
+
+    if not yielded:
+        # If nothing was found, raise an error
+        msg = "NLTK was unable to find %s!" % name_pattern
+        if env_vars:
+            msg += " Set the %s environment variable" % env_vars[0]
+        msg = textwrap.fill(msg + ".", initial_indent="  ", subsequent_indent="  ")
+        if searchpath:
+            msg += "\n\n  Searched in:"
+            msg += "".join("\n    - %s" % d for d in searchpath)
+        if url:
+            msg += "\n\n  For more information, on {}, see:\n    <{}>".format(
+                name_pattern,
+                url,
+            )
+        div = "=" * 75
+        raise LookupError(f"\n\n{div}\n{msg}\n{div}")
+
+
+def find_jar(
+    name_pattern,
+    path_to_jar=None,
+    env_vars=(),
+    searchpath=(),
+    url=None,
+    verbose=False,
+    is_regex=False,
+):
+    return next(
+        find_jar_iter(
+            name_pattern, path_to_jar, env_vars, searchpath, url, verbose, is_regex
+        )
+    )
+
+
+def find_jars_within_path(path_to_jars):
+    return [
+        os.path.join(root, filename)
+        for root, dirnames, filenames in os.walk(path_to_jars)
+        for filename in fnmatch.filter(filenames, "*.jar")
+    ]
+
+
+def _decode_stdoutdata(stdoutdata):
+    """Convert data read from stdout/stderr to unicode"""
+    if not isinstance(stdoutdata, bytes):
+        return stdoutdata
+
+    encoding = getattr(sys.__stdout__, "encoding", locale.getpreferredencoding())
+    if encoding is None:
+        return stdoutdata.decode()
+    return stdoutdata.decode(encoding)
+
+
+##########################################################################
+# Import Stdlib Module
+##########################################################################
+
+
+def import_from_stdlib(module):
+    """
+    When python is run from within the nltk/ directory tree, the
+    current directory is included at the beginning of the search path.
+    Unfortunately, that means that modules within nltk can sometimes
+    shadow standard library modules.  As an example, the stdlib
+    'inspect' module will attempt to import the stdlib 'tokenize'
+    module, but will instead end up importing NLTK's 'tokenize' module
+    instead (causing the import to fail).
+    """
+    old_path = sys.path
+    sys.path = [d for d in sys.path if d not in ("", ".")]
+    m = __import__(module)
+    sys.path = old_path
+    return m
+
+
+##########################################################################
+# Wrapper for ElementTree Elements
+##########################################################################
+
+
+class ElementWrapper:
+    """
+    A wrapper around ElementTree Element objects whose main purpose is
+    to provide nicer __repr__ and __str__ methods.  In addition, any
+    of the wrapped Element's methods that return other Element objects
+    are overridden to wrap those values before returning them.
+
+    This makes Elements more convenient to work with in
+    interactive sessions and doctests, at the expense of some
+    efficiency.
+    """
+
+    # Prevent double-wrapping:
+    def __new__(cls, etree):
+        """
+        Create and return a wrapper around a given Element object.
+        If ``etree`` is an ``ElementWrapper``, then ``etree`` is
+        returned as-is.
+        """
+        if isinstance(etree, ElementWrapper):
+            return etree
+        else:
+            return object.__new__(ElementWrapper)
+
+    def __init__(self, etree):
+        r"""
+        Initialize a new Element wrapper for ``etree``.
+
+        If ``etree`` is a string, then it will be converted to an
+        Element object using ``ElementTree.fromstring()`` first:
+
+            >>> ElementWrapper("<test></test>")
+            <Element "<?xml version='1.0' encoding='utf8'?>\n<test />">
+
+        """
+        if isinstance(etree, str):
+            etree = ElementTree.fromstring(etree)
+        self.__dict__["_etree"] = etree
+
+    def unwrap(self):
+        """
+        Return the Element object wrapped by this wrapper.
+        """
+        return self._etree
+
+    ##////////////////////////////////////////////////////////////
+    # { String Representation
+    ##////////////////////////////////////////////////////////////
+
+    def __repr__(self):
+        s = ElementTree.tostring(self._etree, encoding="utf8").decode("utf8")
+        if len(s) > 60:
+            e = s.rfind("<")
+            if (len(s) - e) > 30:
+                e = -20
+            s = f"{s[:30]}...{s[e:]}"
+        return "<Element %r>" % s
+
+    def __str__(self):
+        """
+        :return: the result of applying ``ElementTree.tostring()`` to
+        the wrapped Element object.
+        """
+        return (
+            ElementTree.tostring(self._etree, encoding="utf8").decode("utf8").rstrip()
+        )
+
+    ##////////////////////////////////////////////////////////////
+    # { Element interface Delegation (pass-through)
+    ##////////////////////////////////////////////////////////////
+
+    def __getattr__(self, attrib):
+        return getattr(self._etree, attrib)
+
+    def __setattr__(self, attr, value):
+        return setattr(self._etree, attr, value)
+
+    def __delattr__(self, attr):
+        return delattr(self._etree, attr)
+
+    def __setitem__(self, index, element):
+        self._etree[index] = element
+
+    def __delitem__(self, index):
+        del self._etree[index]
+
+    def __setslice__(self, start, stop, elements):
+        self._etree[start:stop] = elements
+
+    def __delslice__(self, start, stop):
+        del self._etree[start:stop]
+
+    def __len__(self):
+        return len(self._etree)
+
+    ##////////////////////////////////////////////////////////////
+    # { Element interface Delegation (wrap result)
+    ##////////////////////////////////////////////////////////////
+
+    def __getitem__(self, index):
+        return ElementWrapper(self._etree[index])
+
+    def __getslice__(self, start, stop):
+        return [ElementWrapper(elt) for elt in self._etree[start:stop]]
+
+    def getchildren(self):
+        return [ElementWrapper(elt) for elt in self._etree]
+
+    def getiterator(self, tag=None):
+        return (ElementWrapper(elt) for elt in self._etree.getiterator(tag))
+
+    def makeelement(self, tag, attrib):
+        return ElementWrapper(self._etree.makeelement(tag, attrib))
+
+    def find(self, path):
+        elt = self._etree.find(path)
+        if elt is None:
+            return elt
+        else:
+            return ElementWrapper(elt)
+
+    def findall(self, path):
+        return [ElementWrapper(elt) for elt in self._etree.findall(path)]
+
+
+######################################################################
+# Helper for Handling Slicing
+######################################################################
+
+
+def slice_bounds(sequence, slice_obj, allow_step=False):
+    """
+    Given a slice, return the corresponding (start, stop) bounds,
+    taking into account None indices and negative indices.  The
+    following guarantees are made for the returned start and stop values:
+
+      - 0 <= start <= len(sequence)
+      - 0 <= stop <= len(sequence)
+      - start <= stop
+
+    :raise ValueError: If ``slice_obj.step`` is not None.
+    :param allow_step: If true, then the slice object may have a
+        non-None step.  If it does, then return a tuple
+        (start, stop, step).
+    """
+    start, stop = (slice_obj.start, slice_obj.stop)
+
+    # If allow_step is true, then include the step in our return
+    # value tuple.
+    if allow_step:
+        step = slice_obj.step
+        if step is None:
+            step = 1
+        # Use a recursive call without allow_step to find the slice
+        # bounds.  If step is negative, then the roles of start and
+        # stop (in terms of default values, etc), are swapped.
+        if step < 0:
+            start, stop = slice_bounds(sequence, slice(stop, start))
+        else:
+            start, stop = slice_bounds(sequence, slice(start, stop))
+        return start, stop, step
+
+    # Otherwise, make sure that no non-default step value is used.
+    elif slice_obj.step not in (None, 1):
+        raise ValueError(
+            "slices with steps are not supported by %s" % sequence.__class__.__name__
+        )
+
+    # Supply default offsets.
+    if start is None:
+        start = 0
+    if stop is None:
+        stop = len(sequence)
+
+    # Handle negative indices.
+    if start < 0:
+        start = max(0, len(sequence) + start)
+    if stop < 0:
+        stop = max(0, len(sequence) + stop)
+
+    # Make sure stop doesn't go past the end of the list.  Note that
+    # we avoid calculating len(sequence) if possible, because for lazy
+    # sequences, calculating the length of a sequence can be expensive.
+    if stop > 0:
+        try:
+            sequence[stop - 1]
+        except IndexError:
+            stop = len(sequence)
+
+    # Make sure start isn't past stop.
+    start = min(start, stop)
+
+    # That's all folks!
+    return start, stop
+
+
+######################################################################
+# Permission Checking
+######################################################################
+
+
+def is_writable(path):
+    # Ensure that it exists.
+    if not os.path.exists(path):
+        return False
+
+    # If we're on a posix system, check its permissions.
+    if hasattr(os, "getuid"):
+        statdata = os.stat(path)
+        perm = stat.S_IMODE(statdata.st_mode)
+        # is it world-writable?
+        if perm & 0o002:
+            return True
+        # do we own it?
+        elif statdata.st_uid == os.getuid() and (perm & 0o200):
+            return True
+        # are we in a group that can write to it?
+        elif (statdata.st_gid in [os.getgid()] + os.getgroups()) and (perm & 0o020):
+            return True
+        # otherwise, we can't write to it.
+        else:
+            return False
+
+    # Otherwise, we'll assume it's writable.
+    # [xx] should we do other checks on other platforms?
+    return True
+
+
+######################################################################
+# NLTK Error reporting
+######################################################################
+
+
+def raise_unorderable_types(ordering, a, b):
+    raise TypeError(
+        "unorderable types: %s() %s %s()"
+        % (type(a).__name__, ordering, type(b).__name__)
+    )

llmeval-env/lib/python3.10/site-packages/nltk/jsontags.py

@@ -0,0 +1,65 @@
+# Natural Language Toolkit: JSON Encoder/Decoder Helpers
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Xu <[email protected]>
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Register JSON tags, so the nltk data loader knows what module and class to look for.
+
+NLTK uses simple '!' tags to mark the types of objects, but the fully-qualified
+"tag:nltk.org,2011:" prefix is also accepted in case anyone ends up
+using it.
+"""
+
+import json
+
+json_tags = {}
+
+TAG_PREFIX = "!"
+
+
+def register_tag(cls):
+    """
+    Decorates a class to register it's json tag.
+    """
+    json_tags[TAG_PREFIX + getattr(cls, "json_tag")] = cls
+    return cls
+
+
+class JSONTaggedEncoder(json.JSONEncoder):
+    def default(self, obj):
+        obj_tag = getattr(obj, "json_tag", None)
+        if obj_tag is None:
+            return super().default(obj)
+        obj_tag = TAG_PREFIX + obj_tag
+        obj = obj.encode_json_obj()
+        return {obj_tag: obj}
+
+
+class JSONTaggedDecoder(json.JSONDecoder):
+    def decode(self, s):
+        return self.decode_obj(super().decode(s))
+
+    @classmethod
+    def decode_obj(cls, obj):
+        # Decode nested objects first.
+        if isinstance(obj, dict):
+            obj = {key: cls.decode_obj(val) for (key, val) in obj.items()}
+        elif isinstance(obj, list):
+            obj = list(cls.decode_obj(val) for val in obj)
+        # Check if we have a tagged object.
+        if not isinstance(obj, dict) or len(obj) != 1:
+            return obj
+        obj_tag = next(iter(obj.keys()))
+        if not obj_tag.startswith("!"):
+            return obj
+        if obj_tag not in json_tags:
+            raise ValueError("Unknown tag", obj_tag)
+        obj_cls = json_tags[obj_tag]
+        return obj_cls.decode_json_obj(obj[obj_tag])
+
+
+__all__ = ["register_tag", "json_tags", "JSONTaggedEncoder", "JSONTaggedDecoder"]

llmeval-env/lib/python3.10/site-packages/nltk/langnames.py

@@ -0,0 +1,730 @@
+# Natural Language Toolkit: Language Codes
+#
+# Copyright (C) 2022-2023 NLTK Project
+# Author: Eric Kafe <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+# iso639-3 language codes (C) https://iso639-3.sil.org/
+
+"""
+Translate between language names and language codes.
+
+The iso639-3 language codes were downloaded from the registration authority at
+https://iso639-3.sil.org/
+
+The iso639-3 codeset is evolving, so retired language codes are kept in the
+"iso639retired" dictionary, which is used as fallback by the wrapper functions
+"langname" and "langcode", in order to support the lookup of retired codes.
+
+The "langcode" function returns the current iso639-3 code if there is one,
+and falls back to the retired code otherwise. As specified by BCP-47,
+it returns the shortest (2-letter) code by default, but 3-letter codes
+are also available:
+
+    >>> import nltk.langnames as lgn
+    >>> lgn.langname('fri')          #'fri' is a retired code
+    'Western Frisian'
+
+    The current code is different from the retired one:
+    >>> lgn.langcode('Western Frisian')
+    'fy'
+
+    >>> lgn.langcode('Western Frisian', typ = 3)
+    'fry'
+
+"""
+
+import re
+from warnings import warn
+
+from nltk.corpus import bcp47
+
+codepattern = re.compile("[a-z][a-z][a-z]?")
+
+
+def langname(tag, typ="full"):
+    """
+    Convert a composite BCP-47 tag to a language name
+
+    >>> from nltk.langnames import langname
+    >>> langname('ca-Latn-ES-valencia')
+    'Catalan: Latin: Spain: Valencian'
+
+    >>> langname('ca-Latn-ES-valencia', typ="short")
+    'Catalan'
+    """
+    tags = tag.split("-")
+    code = tags[0].lower()
+    if codepattern.fullmatch(code):
+        if code in iso639retired:  # retired codes
+            return iso639retired[code]
+        elif code in iso639short:  # 3-letter codes
+            code2 = iso639short[code]  # convert to 2-letter code
+            warn(f"Shortening {code!r} to {code2!r}", stacklevel=2)
+            tag = "-".join([code2] + tags[1:])
+        name = bcp47.name(tag)  # parse according to BCP-47
+        if typ == "full":
+            return name  # include all subtags
+        elif name:
+            return name.split(":")[0]  # only the language subtag
+    else:
+        warn(f"Could not find code in {code!r}", stacklevel=2)
+
+
+def langcode(name, typ=2):
+    """
+    Convert language name to iso639-3 language code. Returns the short 2-letter
+    code by default, if one is available, and the 3-letter code otherwise:
+
+    >>> from nltk.langnames import langcode
+    >>> langcode('Modern Greek (1453-)')
+    'el'
+
+    Specify 'typ=3' to get the 3-letter code:
+
+    >>> langcode('Modern Greek (1453-)', typ=3)
+    'ell'
+    """
+    if name in bcp47.langcode:
+        code = bcp47.langcode[name]
+        if typ == 3 and code in iso639long:
+            code = iso639long[code]  # convert to 3-letter code
+        return code
+    elif name in iso639code_retired:
+        return iso639code_retired[name]
+    else:
+        warn(f"Could not find language in {name!r}", stacklevel=2)
+
+
+# =======================================================================
+# Translate betwwen Wikidata Q-codes and BCP-47 codes or names
+# .......................................................................
+
+
+def tag2q(tag):
+    """
+    Convert BCP-47 tag to Wikidata Q-code
+
+    >>> tag2q('nds-u-sd-demv')
+    'Q4289225'
+    """
+    return bcp47.wiki_q[tag]
+
+
+def q2tag(qcode):
+    """
+    Convert Wikidata Q-code to BCP-47 tag
+
+    >>> q2tag('Q4289225')
+    'nds-u-sd-demv'
+    """
+    return wiki_bcp47[qcode]
+
+
+def q2name(qcode, typ="full"):
+    """
+    Convert Wikidata Q-code to BCP-47 (full or short) language name
+
+    >>> q2name('Q4289225')
+    'Low German: Mecklenburg-Vorpommern'
+
+    >>> q2name('Q4289225', "short")
+    'Low German'
+    """
+    return langname(q2tag(qcode), typ)
+
+
+def lang2q(name):
+    """
+    Convert simple language name to Wikidata Q-code
+
+    >>> lang2q('Low German')
+    'Q25433'
+    """
+    return tag2q(langcode(name))
+
+
+# ======================================================================
+# Data dictionaries
+# ......................................................................
+
+
+def inverse_dict(dic):
+    """Return inverse mapping, but only if it is bijective"""
+    if len(dic.keys()) == len(set(dic.values())):
+        return {val: key for (key, val) in dic.items()}
+    else:
+        warn("This dictionary has no bijective inverse mapping.")
+
+
+bcp47.load_wiki_q()  # Wikidata conversion table needs to be loaded explicitly
+wiki_bcp47 = inverse_dict(bcp47.wiki_q)
+
+iso639short = {
+    "aar": "aa",
+    "abk": "ab",
+    "afr": "af",
+    "aka": "ak",
+    "amh": "am",
+    "ara": "ar",
+    "arg": "an",
+    "asm": "as",
+    "ava": "av",
+    "ave": "ae",
+    "aym": "ay",
+    "aze": "az",
+    "bak": "ba",
+    "bam": "bm",
+    "bel": "be",
+    "ben": "bn",
+    "bis": "bi",
+    "bod": "bo",
+    "bos": "bs",
+    "bre": "br",
+    "bul": "bg",
+    "cat": "ca",
+    "ces": "cs",
+    "cha": "ch",
+    "che": "ce",
+    "chu": "cu",
+    "chv": "cv",
+    "cor": "kw",
+    "cos": "co",
+    "cre": "cr",
+    "cym": "cy",
+    "dan": "da",
+    "deu": "de",
+    "div": "dv",
+    "dzo": "dz",
+    "ell": "el",
+    "eng": "en",
+    "epo": "eo",
+    "est": "et",
+    "eus": "eu",
+    "ewe": "ee",
+    "fao": "fo",
+    "fas": "fa",
+    "fij": "fj",
+    "fin": "fi",
+    "fra": "fr",
+    "fry": "fy",
+    "ful": "ff",
+    "gla": "gd",
+    "gle": "ga",
+    "glg": "gl",
+    "glv": "gv",
+    "grn": "gn",
+    "guj": "gu",
+    "hat": "ht",
+    "hau": "ha",
+    "hbs": "sh",
+    "heb": "he",
+    "her": "hz",
+    "hin": "hi",
+    "hmo": "ho",
+    "hrv": "hr",
+    "hun": "hu",
+    "hye": "hy",
+    "ibo": "ig",
+    "ido": "io",
+    "iii": "ii",
+    "iku": "iu",
+    "ile": "ie",
+    "ina": "ia",
+    "ind": "id",
+    "ipk": "ik",
+    "isl": "is",
+    "ita": "it",
+    "jav": "jv",
+    "jpn": "ja",
+    "kal": "kl",
+    "kan": "kn",
+    "kas": "ks",
+    "kat": "ka",
+    "kau": "kr",
+    "kaz": "kk",
+    "khm": "km",
+    "kik": "ki",
+    "kin": "rw",
+    "kir": "ky",
+    "kom": "kv",
+    "kon": "kg",
+    "kor": "ko",
+    "kua": "kj",
+    "kur": "ku",
+    "lao": "lo",
+    "lat": "la",
+    "lav": "lv",
+    "lim": "li",
+    "lin": "ln",
+    "lit": "lt",
+    "ltz": "lb",
+    "lub": "lu",
+    "lug": "lg",
+    "mah": "mh",
+    "mal": "ml",
+    "mar": "mr",
+    "mkd": "mk",
+    "mlg": "mg",
+    "mlt": "mt",
+    "mon": "mn",
+    "mri": "mi",
+    "msa": "ms",
+    "mya": "my",
+    "nau": "na",
+    "nav": "nv",
+    "nbl": "nr",
+    "nde": "nd",
+    "ndo": "ng",
+    "nep": "ne",
+    "nld": "nl",
+    "nno": "nn",
+    "nob": "nb",
+    "nor": "no",
+    "nya": "ny",
+    "oci": "oc",
+    "oji": "oj",
+    "ori": "or",
+    "orm": "om",
+    "oss": "os",
+    "pan": "pa",
+    "pli": "pi",
+    "pol": "pl",
+    "por": "pt",
+    "pus": "ps",
+    "que": "qu",
+    "roh": "rm",
+    "ron": "ro",
+    "run": "rn",
+    "rus": "ru",
+    "sag": "sg",
+    "san": "sa",
+    "sin": "si",
+    "slk": "sk",
+    "slv": "sl",
+    "sme": "se",
+    "smo": "sm",
+    "sna": "sn",
+    "snd": "sd",
+    "som": "so",
+    "sot": "st",
+    "spa": "es",
+    "sqi": "sq",
+    "srd": "sc",
+    "srp": "sr",
+    "ssw": "ss",
+    "sun": "su",
+    "swa": "sw",
+    "swe": "sv",
+    "tah": "ty",
+    "tam": "ta",
+    "tat": "tt",
+    "tel": "te",
+    "tgk": "tg",
+    "tgl": "tl",
+    "tha": "th",
+    "tir": "ti",
+    "ton": "to",
+    "tsn": "tn",
+    "tso": "ts",
+    "tuk": "tk",
+    "tur": "tr",
+    "twi": "tw",
+    "uig": "ug",
+    "ukr": "uk",
+    "urd": "ur",
+    "uzb": "uz",
+    "ven": "ve",
+    "vie": "vi",
+    "vol": "vo",
+    "wln": "wa",
+    "wol": "wo",
+    "xho": "xh",
+    "yid": "yi",
+    "yor": "yo",
+    "zha": "za",
+    "zho": "zh",
+    "zul": "zu",
+}
+
+
+iso639retired = {
+    "fri": "Western Frisian",
+    "auv": "Auvergnat",
+    "gsc": "Gascon",
+    "lms": "Limousin",
+    "lnc": "Languedocien",
+    "prv": "Provençal",
+    "amd": "Amapá Creole",
+    "bgh": "Bogan",
+    "bnh": "Banawá",
+    "bvs": "Belgian Sign Language",
+    "ccy": "Southern Zhuang",
+    "cit": "Chittagonian",
+    "flm": "Falam Chin",
+    "jap": "Jaruára",
+    "kob": "Kohoroxitari",
+    "mob": "Moinba",
+    "mzf": "Aiku",
+    "nhj": "Tlalitzlipa Nahuatl",
+    "nhs": "Southeastern Puebla Nahuatl",
+    "occ": "Occidental",
+    "tmx": "Tomyang",
+    "tot": "Patla-Chicontla Totonac",
+    "xmi": "Miarrã",
+    "yib": "Yinglish",
+    "ztc": "Lachirioag Zapotec",
+    "atf": "Atuence",
+    "bqe": "Navarro-Labourdin Basque",
+    "bsz": "Souletin Basque",
+    "aex": "Amerax",
+    "ahe": "Ahe",
+    "aiz": "Aari",
+    "akn": "Amikoana",
+    "arf": "Arafundi",
+    "azr": "Adzera",
+    "bcx": "Pamona",
+    "bii": "Bisu",
+    "bke": "Bengkulu",
+    "blu": "Hmong Njua",
+    "boc": "Bakung Kenyah",
+    "bsd": "Sarawak Bisaya",
+    "bwv": "Bahau River Kenyah",
+    "bxt": "Buxinhua",
+    "byu": "Buyang",
+    "ccx": "Northern Zhuang",
+    "cru": "Carútana",
+    "dat": "Darang Deng",
+    "dyk": "Land Dayak",
+    "eni": "Enim",
+    "fiz": "Izere",
+    "gen": "Geman Deng",
+    "ggh": "Garreh-Ajuran",
+    "itu": "Itutang",
+    "kds": "Lahu Shi",
+    "knh": "Kayan River Kenyah",
+    "krg": "North Korowai",
+    "krq": "Krui",
+    "kxg": "Katingan",
+    "lmt": "Lematang",
+    "lnt": "Lintang",
+    "lod": "Berawan",
+    "mbg": "Northern Nambikuára",
+    "mdo": "Southwest Gbaya",
+    "mhv": "Arakanese",
+    "miv": "Mimi",
+    "mqd": "Madang",
+    "nky": "Khiamniungan Naga",
+    "nxj": "Nyadu",
+    "ogn": "Ogan",
+    "ork": "Orokaiva",
+    "paj": "Ipeka-Tapuia",
+    "pec": "Southern Pesisir",
+    "pen": "Penesak",
+    "plm": "Palembang",
+    "poj": "Lower Pokomo",
+    "pun": "Pubian",
+    "rae": "Ranau",
+    "rjb": "Rajbanshi",
+    "rws": "Rawas",
+    "sdd": "Semendo",
+    "sdi": "Sindang Kelingi",
+    "skl": "Selako",
+    "slb": "Kahumamahon Saluan",
+    "srj": "Serawai",
+    "suf": "Tarpia",
+    "suh": "Suba",
+    "suu": "Sungkai",
+    "szk": "Sizaki",
+    "tle": "Southern Marakwet",
+    "tnj": "Tanjong",
+    "ttx": "Tutong 1",
+    "ubm": "Upper Baram Kenyah",
+    "vky": "Kayu Agung",
+    "vmo": "Muko-Muko",
+    "wre": "Ware",
+    "xah": "Kahayan",
+    "xkm": "Mahakam Kenyah",
+    "xuf": "Kunfal",
+    "yio": "Dayao Yi",
+    "ymj": "Muji Yi",
+    "ypl": "Pula Yi",
+    "ypw": "Puwa Yi",
+    "ywm": "Wumeng Yi",
+    "yym": "Yuanjiang-Mojiang Yi",
+    "mly": "Malay (individual language)",
+    "muw": "Mundari",
+    "xst": "Silt'e",
+    "ope": "Old Persian",
+    "scc": "Serbian",
+    "scr": "Croatian",
+    "xsk": "Sakan",
+    "mol": "Moldavian",
+    "aay": "Aariya",
+    "acc": "Cubulco Achí",
+    "cbm": "Yepocapa Southwestern Cakchiquel",
+    "chs": "Chumash",
+    "ckc": "Northern Cakchiquel",
+    "ckd": "South Central Cakchiquel",
+    "cke": "Eastern Cakchiquel",
+    "ckf": "Southern Cakchiquel",
+    "cki": "Santa María De Jesús Cakchiquel",
+    "ckj": "Santo Domingo Xenacoj Cakchiquel",
+    "ckk": "Acatenango Southwestern Cakchiquel",
+    "ckw": "Western Cakchiquel",
+    "cnm": "Ixtatán Chuj",
+    "cti": "Tila Chol",
+    "cun": "Cunén Quiché",
+    "eml": "Emiliano-Romagnolo",
+    "eur": "Europanto",
+    "gmo": "Gamo-Gofa-Dawro",
+    "hsf": "Southeastern Huastec",
+    "hva": "San Luís Potosí Huastec",
+    "ixi": "Nebaj Ixil",
+    "ixj": "Chajul Ixil",
+    "jai": "Western Jacalteco",
+    "mms": "Southern Mam",
+    "mpf": "Tajumulco Mam",
+    "mtz": "Tacanec",
+    "mvc": "Central Mam",
+    "mvj": "Todos Santos Cuchumatán Mam",
+    "poa": "Eastern Pokomam",
+    "pob": "Western Pokomchí",
+    "pou": "Southern Pokomam",
+    "ppv": "Papavô",
+    "quj": "Joyabaj Quiché",
+    "qut": "West Central Quiché",
+    "quu": "Eastern Quiché",
+    "qxi": "San Andrés Quiché",
+    "sic": "Malinguat",
+    "stc": "Santa Cruz",
+    "tlz": "Toala'",
+    "tzb": "Bachajón Tzeltal",
+    "tzc": "Chamula Tzotzil",
+    "tze": "Chenalhó Tzotzil",
+    "tzs": "San Andrés Larrainzar Tzotzil",
+    "tzt": "Western Tzutujil",
+    "tzu": "Huixtán Tzotzil",
+    "tzz": "Zinacantán Tzotzil",
+    "vlr": "Vatrata",
+    "yus": "Chan Santa Cruz Maya",
+    "nfg": "Nyeng",
+    "nfk": "Shakara",
+    "agp": "Paranan",
+    "bhk": "Albay Bicolano",
+    "bkb": "Finallig",
+    "btb": "Beti (Cameroon)",
+    "cjr": "Chorotega",
+    "cmk": "Chimakum",
+    "drh": "Darkhat",
+    "drw": "Darwazi",
+    "gav": "Gabutamon",
+    "mof": "Mohegan-Montauk-Narragansett",
+    "mst": "Cataelano Mandaya",
+    "myt": "Sangab Mandaya",
+    "rmr": "Caló",
+    "sgl": "Sanglechi-Ishkashimi",
+    "sul": "Surigaonon",
+    "sum": "Sumo-Mayangna",
+    "tnf": "Tangshewi",
+    "wgw": "Wagawaga",
+    "ayx": "Ayi (China)",
+    "bjq": "Southern Betsimisaraka Malagasy",
+    "dha": "Dhanwar (India)",
+    "dkl": "Kolum So Dogon",
+    "mja": "Mahei",
+    "nbf": "Naxi",
+    "noo": "Nootka",
+    "tie": "Tingal",
+    "tkk": "Takpa",
+    "baz": "Tunen",
+    "bjd": "Bandjigali",
+    "ccq": "Chaungtha",
+    "cka": "Khumi Awa Chin",
+    "dap": "Nisi (India)",
+    "dwl": "Walo Kumbe Dogon",
+    "elp": "Elpaputih",
+    "gbc": "Garawa",
+    "gio": "Gelao",
+    "hrr": "Horuru",
+    "ibi": "Ibilo",
+    "jar": "Jarawa (Nigeria)",
+    "kdv": "Kado",
+    "kgh": "Upper Tanudan Kalinga",
+    "kpp": "Paku Karen",
+    "kzh": "Kenuzi-Dongola",
+    "lcq": "Luhu",
+    "mgx": "Omati",
+    "nln": "Durango Nahuatl",
+    "pbz": "Palu",
+    "pgy": "Pongyong",
+    "sca": "Sansu",
+    "tlw": "South Wemale",
+    "unp": "Worora",
+    "wiw": "Wirangu",
+    "ybd": "Yangbye",
+    "yen": "Yendang",
+    "yma": "Yamphe",
+    "daf": "Dan",
+    "djl": "Djiwarli",
+    "ggr": "Aghu Tharnggalu",
+    "ilw": "Talur",
+    "izi": "Izi-Ezaa-Ikwo-Mgbo",
+    "meg": "Mea",
+    "mld": "Malakhel",
+    "mnt": "Maykulan",
+    "mwd": "Mudbura",
+    "myq": "Forest Maninka",
+    "nbx": "Ngura",
+    "nlr": "Ngarla",
+    "pcr": "Panang",
+    "ppr": "Piru",
+    "tgg": "Tangga",
+    "wit": "Wintu",
+    "xia": "Xiandao",
+    "yiy": "Yir Yoront",
+    "yos": "Yos",
+    "emo": "Emok",
+    "ggm": "Gugu Mini",
+    "leg": "Lengua",
+    "lmm": "Lamam",
+    "mhh": "Maskoy Pidgin",
+    "puz": "Purum Naga",
+    "sap": "Sanapaná",
+    "yuu": "Yugh",
+    "aam": "Aramanik",
+    "adp": "Adap",
+    "aue": "ǂKxʼauǁʼein",
+    "bmy": "Bemba (Democratic Republic of Congo)",
+    "bxx": "Borna (Democratic Republic of Congo)",
+    "byy": "Buya",
+    "dzd": "Daza",
+    "gfx": "Mangetti Dune ǃXung",
+    "gti": "Gbati-ri",
+    "ime": "Imeraguen",
+    "kbf": "Kakauhua",
+    "koj": "Sara Dunjo",
+    "kwq": "Kwak",
+    "kxe": "Kakihum",
+    "lii": "Lingkhim",
+    "mwj": "Maligo",
+    "nnx": "Ngong",
+    "oun": "ǃOǃung",
+    "pmu": "Mirpur Panjabi",
+    "sgo": "Songa",
+    "thx": "The",
+    "tsf": "Southwestern Tamang",
+    "uok": "Uokha",
+    "xsj": "Subi",
+    "yds": "Yiddish Sign Language",
+    "ymt": "Mator-Taygi-Karagas",
+    "ynh": "Yangho",
+    "bgm": "Baga Mboteni",
+    "btl": "Bhatola",
+    "cbe": "Chipiajes",
+    "cbh": "Cagua",
+    "coy": "Coyaima",
+    "cqu": "Chilean Quechua",
+    "cum": "Cumeral",
+    "duj": "Dhuwal",
+    "ggn": "Eastern Gurung",
+    "ggo": "Southern Gondi",
+    "guv": "Gey",
+    "iap": "Iapama",
+    "ill": "Iranun",
+    "kgc": "Kasseng",
+    "kox": "Coxima",
+    "ktr": "Kota Marudu Tinagas",
+    "kvs": "Kunggara",
+    "kzj": "Coastal Kadazan",
+    "kzt": "Tambunan Dusun",
+    "nad": "Nijadali",
+    "nts": "Natagaimas",
+    "ome": "Omejes",
+    "pmc": "Palumata",
+    "pod": "Ponares",
+    "ppa": "Pao",
+    "pry": "Pray 3",
+    "rna": "Runa",
+    "svr": "Savara",
+    "tdu": "Tempasuk Dusun",
+    "thc": "Tai Hang Tong",
+    "tid": "Tidong",
+    "tmp": "Tai Mène",
+    "tne": "Tinoc Kallahan",
+    "toe": "Tomedes",
+    "xba": "Kamba (Brazil)",
+    "xbx": "Kabixí",
+    "xip": "Xipináwa",
+    "xkh": "Karahawyana",
+    "yri": "Yarí",
+    "jeg": "Jeng",
+    "kgd": "Kataang",
+    "krm": "Krim",
+    "prb": "Lua'",
+    "puk": "Pu Ko",
+    "rie": "Rien",
+    "rsi": "Rennellese Sign Language",
+    "skk": "Sok",
+    "snh": "Shinabo",
+    "lsg": "Lyons Sign Language",
+    "mwx": "Mediak",
+    "mwy": "Mosiro",
+    "ncp": "Ndaktup",
+    "ais": "Nataoran Amis",
+    "asd": "Asas",
+    "dit": "Dirari",
+    "dud": "Hun-Saare",
+    "lba": "Lui",
+    "llo": "Khlor",
+    "myd": "Maramba",
+    "myi": "Mina (India)",
+    "nns": "Ningye",
+    "aoh": "Arma",
+    "ayy": "Tayabas Ayta",
+    "bbz": "Babalia Creole Arabic",
+    "bpb": "Barbacoas",
+    "cca": "Cauca",
+    "cdg": "Chamari",
+    "dgu": "Degaru",
+    "drr": "Dororo",
+    "ekc": "Eastern Karnic",
+    "gli": "Guliguli",
+    "kjf": "Khalaj",
+    "kxl": "Nepali Kurux",
+    "kxu": "Kui (India)",
+    "lmz": "Lumbee",
+    "nxu": "Narau",
+    "plp": "Palpa",
+    "sdm": "Semandang",
+    "tbb": "Tapeba",
+    "xrq": "Karranga",
+    "xtz": "Tasmanian",
+    "zir": "Ziriya",
+    "thw": "Thudam",
+    "bic": "Bikaru",
+    "bij": "Vaghat-Ya-Bijim-Legeri",
+    "blg": "Balau",
+    "gji": "Geji",
+    "mvm": "Muya",
+    "ngo": "Ngoni",
+    "pat": "Papitalai",
+    "vki": "Ija-Zuba",
+    "wra": "Warapu",
+    "ajt": "Judeo-Tunisian Arabic",
+    "cug": "Chungmboko",
+    "lak": "Laka (Nigeria)",
+    "lno": "Lango (South Sudan)",
+    "pii": "Pini",
+    "smd": "Sama",
+    "snb": "Sebuyau",
+    "uun": "Kulon-Pazeh",
+    "wrd": "Warduji",
+    "wya": "Wyandot",
+}
+
+
+iso639long = inverse_dict(iso639short)
+
+iso639code_retired = inverse_dict(iso639retired)

llmeval-env/lib/python3.10/site-packages/nltk/lazyimport.py

@@ -0,0 +1,142 @@
+# This module is from mx/DateTime/LazyModule.py and is
+# distributed under the terms of the eGenix.com Public License Agreement
+# https://www.egenix.com/products/eGenix.com-Public-License-1.1.0.pdf
+
+""" Helper to enable simple lazy module import.
+
+    'Lazy' means the actual import is deferred until an attribute is
+    requested from the module's namespace. This has the advantage of
+    allowing all imports to be done at the top of a script (in a
+    prominent and visible place) without having a great impact
+    on startup time.
+
+    Copyright (c) 1999-2005, Marc-Andre Lemburg; mailto:[email protected]
+    See the documentation for further information on copyrights,
+    or contact the author. All Rights Reserved.
+"""
+
+### Constants
+
+_debug = 0
+
+###
+
+
+class LazyModule:
+
+    """Lazy module class.
+
+    Lazy modules are imported into the given namespaces whenever a
+    non-special attribute (there are some attributes like __doc__
+    that class instances handle without calling __getattr__) is
+    requested. The module is then registered under the given name
+    in locals usually replacing the import wrapper instance. The
+    import itself is done using globals as global namespace.
+
+    Example of creating a lazy load module:
+
+    ISO = LazyModule('ISO',locals(),globals())
+
+    Later, requesting an attribute from ISO will load the module
+    automatically into the locals() namespace, overriding the
+    LazyModule instance:
+
+    t = ISO.Week(1998,1,1)
+
+    """
+
+    # Flag which indicates whether the LazyModule is initialized or not
+    __lazymodule_init = 0
+
+    # Name of the module to load
+    __lazymodule_name = ""
+
+    # Flag which indicates whether the module was loaded or not
+    __lazymodule_loaded = 0
+
+    # Locals dictionary where to register the module
+    __lazymodule_locals = None
+
+    # Globals dictionary to use for the module import
+    __lazymodule_globals = None
+
+    def __init__(self, name, locals, globals=None):
+
+        """Create a LazyModule instance wrapping module name.
+
+        The module will later on be registered in locals under the
+        given module name.
+
+        globals is optional and defaults to locals.
+
+        """
+        self.__lazymodule_locals = locals
+        if globals is None:
+            globals = locals
+        self.__lazymodule_globals = globals
+        mainname = globals.get("__name__", "")
+        if mainname:
+            self.__name__ = mainname + "." + name
+            self.__lazymodule_name = name
+        else:
+            self.__name__ = self.__lazymodule_name = name
+        self.__lazymodule_init = 1
+
+    def __lazymodule_import(self):
+
+        """Import the module now."""
+        # Load and register module
+        local_name = self.__lazymodule_name  # e.g. "toolbox"
+        full_name = self.__name__  # e.g. "nltk.toolbox"
+        if self.__lazymodule_loaded:
+            return self.__lazymodule_locals[local_name]
+        if _debug:
+            print("LazyModule: Loading module %r" % full_name)
+        self.__lazymodule_locals[local_name] = module = __import__(
+            full_name, self.__lazymodule_locals, self.__lazymodule_globals, "*"
+        )
+
+        # Fill namespace with all symbols from original module to
+        # provide faster access.
+        self.__dict__.update(module.__dict__)
+
+        # Set import flag
+        self.__dict__["__lazymodule_loaded"] = 1
+
+        if _debug:
+            print("LazyModule: Module %r loaded" % full_name)
+        return module
+
+    def __getattr__(self, name):
+
+        """Import the module on demand and get the attribute."""
+        if self.__lazymodule_loaded:
+            raise AttributeError(name)
+        if _debug:
+            print(
+                "LazyModule: "
+                "Module load triggered by attribute %r read access" % name
+            )
+        module = self.__lazymodule_import()
+        return getattr(module, name)
+
+    def __setattr__(self, name, value):
+
+        """Import the module on demand and set the attribute."""
+        if not self.__lazymodule_init:
+            self.__dict__[name] = value
+            return
+        if self.__lazymodule_loaded:
+            self.__lazymodule_locals[self.__lazymodule_name] = value
+            self.__dict__[name] = value
+            return
+        if _debug:
+            print(
+                "LazyModule: "
+                "Module load triggered by attribute %r write access" % name
+            )
+        module = self.__lazymodule_import()
+        setattr(module, name, value)
+
+    def __repr__(self):
+        return "<LazyModule '%s'>" % self.__name__

llmeval-env/lib/python3.10/site-packages/nltk/probability.py

@@ -0,0 +1,2578 @@
+# Natural Language Toolkit: Probability and Statistics
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]> (additions)
+#         Trevor Cohn <[email protected]> (additions)
+#         Peter Ljunglöf <[email protected]> (additions)
+#         Liang Dong <[email protected]> (additions)
+#         Geoffrey Sampson <[email protected]> (additions)
+#         Ilia Kurenkov <[email protected]> (additions)
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Classes for representing and processing probabilistic information.
+
+The ``FreqDist`` class is used to encode "frequency distributions",
+which count the number of times that each outcome of an experiment
+occurs.
+
+The ``ProbDistI`` class defines a standard interface for "probability
+distributions", which encode the probability of each outcome for an
+experiment.  There are two types of probability distribution:
+
+  - "derived probability distributions" are created from frequency
+    distributions.  They attempt to model the probability distribution
+    that generated the frequency distribution.
+  - "analytic probability distributions" are created directly from
+    parameters (such as variance).
+
+The ``ConditionalFreqDist`` class and ``ConditionalProbDistI`` interface
+are used to encode conditional distributions.  Conditional probability
+distributions can be derived or analytic; but currently the only
+implementation of the ``ConditionalProbDistI`` interface is
+``ConditionalProbDist``, a derived distribution.
+
+"""
+
+import array
+import math
+import random
+import warnings
+from abc import ABCMeta, abstractmethod
+from collections import Counter, defaultdict
+from functools import reduce
+
+from nltk.internals import raise_unorderable_types
+
+_NINF = float("-1e300")
+
+##//////////////////////////////////////////////////////
+##  Frequency Distributions
+##//////////////////////////////////////////////////////
+
+
+class FreqDist(Counter):
+    """
+    A frequency distribution for the outcomes of an experiment.  A
+    frequency distribution records the number of times each outcome of
+    an experiment has occurred.  For example, a frequency distribution
+    could be used to record the frequency of each word type in a
+    document.  Formally, a frequency distribution can be defined as a
+    function mapping from each sample to the number of times that
+    sample occurred as an outcome.
+
+    Frequency distributions are generally constructed by running a
+    number of experiments, and incrementing the count for a sample
+    every time it is an outcome of an experiment.  For example, the
+    following code will produce a frequency distribution that encodes
+    how often each word occurs in a text:
+
+        >>> from nltk.tokenize import word_tokenize
+        >>> from nltk.probability import FreqDist
+        >>> sent = 'This is an example sentence'
+        >>> fdist = FreqDist()
+        >>> for word in word_tokenize(sent):
+        ...    fdist[word.lower()] += 1
+
+    An equivalent way to do this is with the initializer:
+
+        >>> fdist = FreqDist(word.lower() for word in word_tokenize(sent))
+
+    """
+
+    def __init__(self, samples=None):
+        """
+        Construct a new frequency distribution.  If ``samples`` is
+        given, then the frequency distribution will be initialized
+        with the count of each object in ``samples``; otherwise, it
+        will be initialized to be empty.
+
+        In particular, ``FreqDist()`` returns an empty frequency
+        distribution; and ``FreqDist(samples)`` first creates an empty
+        frequency distribution, and then calls ``update`` with the
+        list ``samples``.
+
+        :param samples: The samples to initialize the frequency
+            distribution with.
+        :type samples: Sequence
+        """
+        Counter.__init__(self, samples)
+
+        # Cached number of samples in this FreqDist
+        self._N = None
+
+    def N(self):
+        """
+        Return the total number of sample outcomes that have been
+        recorded by this FreqDist.  For the number of unique
+        sample values (or bins) with counts greater than zero, use
+        ``FreqDist.B()``.
+
+        :rtype: int
+        """
+        if self._N is None:
+            # Not already cached, or cache has been invalidated
+            self._N = sum(self.values())
+        return self._N
+
+    def __setitem__(self, key, val):
+        """
+        Override ``Counter.__setitem__()`` to invalidate the cached N
+        """
+        self._N = None
+        super().__setitem__(key, val)
+
+    def __delitem__(self, key):
+        """
+        Override ``Counter.__delitem__()`` to invalidate the cached N
+        """
+        self._N = None
+        super().__delitem__(key)
+
+    def update(self, *args, **kwargs):
+        """
+        Override ``Counter.update()`` to invalidate the cached N
+        """
+        self._N = None
+        super().update(*args, **kwargs)
+
+    def setdefault(self, key, val):
+        """
+        Override ``Counter.setdefault()`` to invalidate the cached N
+        """
+        self._N = None
+        super().setdefault(key, val)
+
+    def B(self):
+        """
+        Return the total number of sample values (or "bins") that
+        have counts greater than zero.  For the total
+        number of sample outcomes recorded, use ``FreqDist.N()``.
+        (FreqDist.B() is the same as len(FreqDist).)
+
+        :rtype: int
+        """
+        return len(self)
+
+    def hapaxes(self):
+        """
+        Return a list of all samples that occur once (hapax legomena)
+
+        :rtype: list
+        """
+        return [item for item in self if self[item] == 1]
+
+    def Nr(self, r, bins=None):
+        return self.r_Nr(bins)[r]
+
+    def r_Nr(self, bins=None):
+        """
+        Return the dictionary mapping r to Nr, the number of samples with frequency r, where Nr > 0.
+
+        :type bins: int
+        :param bins: The number of possible sample outcomes.  ``bins``
+            is used to calculate Nr(0).  In particular, Nr(0) is
+            ``bins-self.B()``.  If ``bins`` is not specified, it
+            defaults to ``self.B()`` (so Nr(0) will be 0).
+        :rtype: int
+        """
+
+        _r_Nr = defaultdict(int)
+        for count in self.values():
+            _r_Nr[count] += 1
+
+        # Special case for Nr[0]:
+        _r_Nr[0] = bins - self.B() if bins is not None else 0
+
+        return _r_Nr
+
+    def _cumulative_frequencies(self, samples):
+        """
+        Return the cumulative frequencies of the specified samples.
+        If no samples are specified, all counts are returned, starting
+        with the largest.
+
+        :param samples: the samples whose frequencies should be returned.
+        :type samples: any
+        :rtype: list(float)
+        """
+        cf = 0.0
+        for sample in samples:
+            cf += self[sample]
+            yield cf
+
+    # slightly odd nomenclature freq() if FreqDist does counts and ProbDist does probs,
+    # here, freq() does probs
+    def freq(self, sample):
+        """
+        Return the frequency of a given sample.  The frequency of a
+        sample is defined as the count of that sample divided by the
+        total number of sample outcomes that have been recorded by
+        this FreqDist.  The count of a sample is defined as the
+        number of times that sample outcome was recorded by this
+        FreqDist.  Frequencies are always real numbers in the range
+        [0, 1].
+
+        :param sample: the sample whose frequency
+               should be returned.
+        :type sample: any
+        :rtype: float
+        """
+        n = self.N()
+        if n == 0:
+            return 0
+        return self[sample] / n
+
+    def max(self):
+        """
+        Return the sample with the greatest number of outcomes in this
+        frequency distribution.  If two or more samples have the same
+        number of outcomes, return one of them; which sample is
+        returned is undefined.  If no outcomes have occurred in this
+        frequency distribution, return None.
+
+        :return: The sample with the maximum number of outcomes in this
+                frequency distribution.
+        :rtype: any or None
+        """
+        if len(self) == 0:
+            raise ValueError(
+                "A FreqDist must have at least one sample before max is defined."
+            )
+        return self.most_common(1)[0][0]
+
+    def plot(
+        self, *args, title="", cumulative=False, percents=False, show=True, **kwargs
+    ):
+        """
+        Plot samples from the frequency distribution
+        displaying the most frequent sample first.  If an integer
+        parameter is supplied, stop after this many samples have been
+        plotted.  For a cumulative plot, specify cumulative=True. Additional
+        ``**kwargs`` are passed to matplotlib's plot function.
+        (Requires Matplotlib to be installed.)
+
+        :param title: The title for the graph.
+        :type title: str
+        :param cumulative: Whether the plot is cumulative. (default = False)
+        :type cumulative: bool
+        :param percents: Whether the plot uses percents instead of counts. (default = False)
+        :type percents: bool
+        :param show: Whether to show the plot, or only return the ax.
+        :type show: bool
+        """
+        try:
+            import matplotlib.pyplot as plt
+        except ImportError as e:
+            raise ValueError(
+                "The plot function requires matplotlib to be installed."
+                "See https://matplotlib.org/"
+            ) from e
+
+        if len(args) == 0:
+            args = [len(self)]
+        samples = [item for item, _ in self.most_common(*args)]
+
+        if cumulative:
+            freqs = list(self._cumulative_frequencies(samples))
+            ylabel = "Cumulative "
+        else:
+            freqs = [self[sample] for sample in samples]
+            ylabel = ""
+
+        if percents:
+            freqs = [f / self.N() * 100 for f in freqs]
+            ylabel += "Percents"
+        else:
+            ylabel += "Counts"
+
+        ax = plt.gca()
+        ax.grid(True, color="silver")
+
+        if "linewidth" not in kwargs:
+            kwargs["linewidth"] = 2
+        if title:
+            ax.set_title(title)
+
+        ax.plot(freqs, **kwargs)
+        ax.set_xticks(range(len(samples)))
+        ax.set_xticklabels([str(s) for s in samples], rotation=90)
+        ax.set_xlabel("Samples")
+        ax.set_ylabel(ylabel)
+
+        if show:
+            plt.show()
+
+        return ax
+
+    def tabulate(self, *args, **kwargs):
+        """
+        Tabulate the given samples from the frequency distribution (cumulative),
+        displaying the most frequent sample first.  If an integer
+        parameter is supplied, stop after this many samples have been
+        plotted.
+
+        :param samples: The samples to plot (default is all samples)
+        :type samples: list
+        :param cumulative: A flag to specify whether the freqs are cumulative (default = False)
+        :type title: bool
+        """
+        if len(args) == 0:
+            args = [len(self)]
+        samples = _get_kwarg(
+            kwargs, "samples", [item for item, _ in self.most_common(*args)]
+        )
+
+        cumulative = _get_kwarg(kwargs, "cumulative", False)
+        if cumulative:
+            freqs = list(self._cumulative_frequencies(samples))
+        else:
+            freqs = [self[sample] for sample in samples]
+        # percents = [f * 100 for f in freqs]  only in ProbDist?
+
+        width = max(len(f"{s}") for s in samples)
+        width = max(width, max(len("%d" % f) for f in freqs))
+
+        for i in range(len(samples)):
+            print("%*s" % (width, samples[i]), end=" ")
+        print()
+        for i in range(len(samples)):
+            print("%*d" % (width, freqs[i]), end=" ")
+        print()
+
+    def copy(self):
+        """
+        Create a copy of this frequency distribution.
+
+        :rtype: FreqDist
+        """
+        return self.__class__(self)
+
+    # Mathematical operatiors
+
+    def __add__(self, other):
+        """
+        Add counts from two counters.
+
+        >>> FreqDist('abbb') + FreqDist('bcc')
+        FreqDist({'b': 4, 'c': 2, 'a': 1})
+
+        """
+        return self.__class__(super().__add__(other))
+
+    def __sub__(self, other):
+        """
+        Subtract count, but keep only results with positive counts.
+
+        >>> FreqDist('abbbc') - FreqDist('bccd')
+        FreqDist({'b': 2, 'a': 1})
+
+        """
+        return self.__class__(super().__sub__(other))
+
+    def __or__(self, other):
+        """
+        Union is the maximum of value in either of the input counters.
+
+        >>> FreqDist('abbb') | FreqDist('bcc')
+        FreqDist({'b': 3, 'c': 2, 'a': 1})
+
+        """
+        return self.__class__(super().__or__(other))
+
+    def __and__(self, other):
+        """
+        Intersection is the minimum of corresponding counts.
+
+        >>> FreqDist('abbb') & FreqDist('bcc')
+        FreqDist({'b': 1})
+
+        """
+        return self.__class__(super().__and__(other))
+
+    def __le__(self, other):
+        """
+        Returns True if this frequency distribution is a subset of the other
+        and for no key the value exceeds the value of the same key from
+        the other frequency distribution.
+
+        The <= operator forms partial order and satisfying the axioms
+        reflexivity, antisymmetry and transitivity.
+
+        >>> FreqDist('a') <= FreqDist('a')
+        True
+        >>> a = FreqDist('abc')
+        >>> b = FreqDist('aabc')
+        >>> (a <= b, b <= a)
+        (True, False)
+        >>> FreqDist('a') <= FreqDist('abcd')
+        True
+        >>> FreqDist('abc') <= FreqDist('xyz')
+        False
+        >>> FreqDist('xyz') <= FreqDist('abc')
+        False
+        >>> c = FreqDist('a')
+        >>> d = FreqDist('aa')
+        >>> e = FreqDist('aaa')
+        >>> c <= d and d <= e and c <= e
+        True
+        """
+        if not isinstance(other, FreqDist):
+            raise_unorderable_types("<=", self, other)
+        return set(self).issubset(other) and all(
+            self[key] <= other[key] for key in self
+        )
+
+    def __ge__(self, other):
+        if not isinstance(other, FreqDist):
+            raise_unorderable_types(">=", self, other)
+        return set(self).issuperset(other) and all(
+            self[key] >= other[key] for key in other
+        )
+
+    __lt__ = lambda self, other: self <= other and not self == other
+    __gt__ = lambda self, other: self >= other and not self == other
+
+    def __repr__(self):
+        """
+        Return a string representation of this FreqDist.
+
+        :rtype: string
+        """
+        return self.pformat()
+
+    def pprint(self, maxlen=10, stream=None):
+        """
+        Print a string representation of this FreqDist to 'stream'
+
+        :param maxlen: The maximum number of items to print
+        :type maxlen: int
+        :param stream: The stream to print to. stdout by default
+        """
+        print(self.pformat(maxlen=maxlen), file=stream)
+
+    def pformat(self, maxlen=10):
+        """
+        Return a string representation of this FreqDist.
+
+        :param maxlen: The maximum number of items to display
+        :type maxlen: int
+        :rtype: string
+        """
+        items = ["{!r}: {!r}".format(*item) for item in self.most_common(maxlen)]
+        if len(self) > maxlen:
+            items.append("...")
+        return "FreqDist({{{0}}})".format(", ".join(items))
+
+    def __str__(self):
+        """
+        Return a string representation of this FreqDist.
+
+        :rtype: string
+        """
+        return "<FreqDist with %d samples and %d outcomes>" % (len(self), self.N())
+
+    def __iter__(self):
+        """
+        Return an iterator which yields tokens ordered by frequency.
+
+        :rtype: iterator
+        """
+        for token, _ in self.most_common(self.B()):
+            yield token
+
+
+##//////////////////////////////////////////////////////
+##  Probability Distributions
+##//////////////////////////////////////////////////////
+
+
+class ProbDistI(metaclass=ABCMeta):
+    """
+    A probability distribution for the outcomes of an experiment.  A
+    probability distribution specifies how likely it is that an
+    experiment will have any given outcome.  For example, a
+    probability distribution could be used to predict the probability
+    that a token in a document will have a given type.  Formally, a
+    probability distribution can be defined as a function mapping from
+    samples to nonnegative real numbers, such that the sum of every
+    number in the function's range is 1.0.  A ``ProbDist`` is often
+    used to model the probability distribution of the experiment used
+    to generate a frequency distribution.
+    """
+
+    SUM_TO_ONE = True
+    """True if the probabilities of the samples in this probability
+       distribution will always sum to one."""
+
+    @abstractmethod
+    def __init__(self):
+        """
+        Classes inheriting from ProbDistI should implement __init__.
+        """
+
+    @abstractmethod
+    def prob(self, sample):
+        """
+        Return the probability for a given sample.  Probabilities
+        are always real numbers in the range [0, 1].
+
+        :param sample: The sample whose probability
+               should be returned.
+        :type sample: any
+        :rtype: float
+        """
+
+    def logprob(self, sample):
+        """
+        Return the base 2 logarithm of the probability for a given sample.
+
+        :param sample: The sample whose probability
+               should be returned.
+        :type sample: any
+        :rtype: float
+        """
+        # Default definition, in terms of prob()
+        p = self.prob(sample)
+        return math.log(p, 2) if p != 0 else _NINF
+
+    @abstractmethod
+    def max(self):
+        """
+        Return the sample with the greatest probability.  If two or
+        more samples have the same probability, return one of them;
+        which sample is returned is undefined.
+
+        :rtype: any
+        """
+
+    @abstractmethod
+    def samples(self):
+        """
+        Return a list of all samples that have nonzero probabilities.
+        Use ``prob`` to find the probability of each sample.
+
+        :rtype: list
+        """
+
+    # cf self.SUM_TO_ONE
+    def discount(self):
+        """
+        Return the ratio by which counts are discounted on average: c*/c
+
+        :rtype: float
+        """
+        return 0.0
+
+    # Subclasses should define more efficient implementations of this,
+    # where possible.
+    def generate(self):
+        """
+        Return a randomly selected sample from this probability distribution.
+        The probability of returning each sample ``samp`` is equal to
+        ``self.prob(samp)``.
+        """
+        p = random.random()
+        p_init = p
+        for sample in self.samples():
+            p -= self.prob(sample)
+            if p <= 0:
+                return sample
+        # allow for some rounding error:
+        if p < 0.0001:
+            return sample
+        # we *should* never get here
+        if self.SUM_TO_ONE:
+            warnings.warn(
+                "Probability distribution %r sums to %r; generate()"
+                " is returning an arbitrary sample." % (self, p_init - p)
+            )
+        return random.choice(list(self.samples()))
+
+
+class UniformProbDist(ProbDistI):
+    """
+    A probability distribution that assigns equal probability to each
+    sample in a given set; and a zero probability to all other
+    samples.
+    """
+
+    def __init__(self, samples):
+        """
+        Construct a new uniform probability distribution, that assigns
+        equal probability to each sample in ``samples``.
+
+        :param samples: The samples that should be given uniform
+            probability.
+        :type samples: list
+        :raise ValueError: If ``samples`` is empty.
+        """
+        if len(samples) == 0:
+            raise ValueError(
+                "A Uniform probability distribution must " + "have at least one sample."
+            )
+        self._sampleset = set(samples)
+        self._prob = 1.0 / len(self._sampleset)
+        self._samples = list(self._sampleset)
+
+    def prob(self, sample):
+        return self._prob if sample in self._sampleset else 0
+
+    def max(self):
+        return self._samples[0]
+
+    def samples(self):
+        return self._samples
+
+    def __repr__(self):
+        return "<UniformProbDist with %d samples>" % len(self._sampleset)
+
+
+class RandomProbDist(ProbDistI):
+    """
+    Generates a random probability distribution whereby each sample
+    will be between 0 and 1 with equal probability (uniform random distribution.
+    Also called a continuous uniform distribution).
+    """
+
+    def __init__(self, samples):
+        if len(samples) == 0:
+            raise ValueError(
+                "A probability distribution must " + "have at least one sample."
+            )
+        self._probs = self.unirand(samples)
+        self._samples = list(self._probs.keys())
+
+    @classmethod
+    def unirand(cls, samples):
+        """
+        The key function that creates a randomized initial distribution
+        that still sums to 1. Set as a dictionary of prob values so that
+        it can still be passed to MutableProbDist and called with identical
+        syntax to UniformProbDist
+        """
+        samples = set(samples)
+        randrow = [random.random() for i in range(len(samples))]
+        total = sum(randrow)
+        for i, x in enumerate(randrow):
+            randrow[i] = x / total
+
+        total = sum(randrow)
+        if total != 1:
+            # this difference, if present, is so small (near NINF) that it
+            # can be subtracted from any element without risking probs not (0 1)
+            randrow[-1] -= total - 1
+
+        return {s: randrow[i] for i, s in enumerate(samples)}
+
+    def max(self):
+        if not hasattr(self, "_max"):
+            self._max = max((p, v) for (v, p) in self._probs.items())[1]
+        return self._max
+
+    def prob(self, sample):
+        return self._probs.get(sample, 0)
+
+    def samples(self):
+        return self._samples
+
+    def __repr__(self):
+        return "<RandomUniformProbDist with %d samples>" % len(self._probs)
+
+
+class DictionaryProbDist(ProbDistI):
+    """
+    A probability distribution whose probabilities are directly
+    specified by a given dictionary.  The given dictionary maps
+    samples to probabilities.
+    """
+
+    def __init__(self, prob_dict=None, log=False, normalize=False):
+        """
+        Construct a new probability distribution from the given
+        dictionary, which maps values to probabilities (or to log
+        probabilities, if ``log`` is true).  If ``normalize`` is
+        true, then the probability values are scaled by a constant
+        factor such that they sum to 1.
+
+        If called without arguments, the resulting probability
+        distribution assigns zero probability to all values.
+        """
+
+        self._prob_dict = prob_dict.copy() if prob_dict is not None else {}
+        self._log = log
+
+        # Normalize the distribution, if requested.
+        if normalize:
+            if len(prob_dict) == 0:
+                raise ValueError(
+                    "A DictionaryProbDist must have at least one sample "
+                    + "before it can be normalized."
+                )
+            if log:
+                value_sum = sum_logs(list(self._prob_dict.values()))
+                if value_sum <= _NINF:
+                    logp = math.log(1.0 / len(prob_dict), 2)
+                    for x in prob_dict:
+                        self._prob_dict[x] = logp
+                else:
+                    for (x, p) in self._prob_dict.items():
+                        self._prob_dict[x] -= value_sum
+            else:
+                value_sum = sum(self._prob_dict.values())
+                if value_sum == 0:
+                    p = 1.0 / len(prob_dict)
+                    for x in prob_dict:
+                        self._prob_dict[x] = p
+                else:
+                    norm_factor = 1.0 / value_sum
+                    for (x, p) in self._prob_dict.items():
+                        self._prob_dict[x] *= norm_factor
+
+    def prob(self, sample):
+        if self._log:
+            return 2 ** (self._prob_dict[sample]) if sample in self._prob_dict else 0
+        else:
+            return self._prob_dict.get(sample, 0)
+
+    def logprob(self, sample):
+        if self._log:
+            return self._prob_dict.get(sample, _NINF)
+        else:
+            if sample not in self._prob_dict:
+                return _NINF
+            elif self._prob_dict[sample] == 0:
+                return _NINF
+            else:
+                return math.log(self._prob_dict[sample], 2)
+
+    def max(self):
+        if not hasattr(self, "_max"):
+            self._max = max((p, v) for (v, p) in self._prob_dict.items())[1]
+        return self._max
+
+    def samples(self):
+        return self._prob_dict.keys()
+
+    def __repr__(self):
+        return "<ProbDist with %d samples>" % len(self._prob_dict)
+
+
+class MLEProbDist(ProbDistI):
+    """
+    The maximum likelihood estimate for the probability distribution
+    of the experiment used to generate a frequency distribution.  The
+    "maximum likelihood estimate" approximates the probability of
+    each sample as the frequency of that sample in the frequency
+    distribution.
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Use the maximum likelihood estimate to create a probability
+        distribution for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        """
+        self._freqdist = freqdist
+
+    def freqdist(self):
+        """
+        Return the frequency distribution that this probability
+        distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._freqdist
+
+    def prob(self, sample):
+        return self._freqdist.freq(sample)
+
+    def max(self):
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def __repr__(self):
+        """
+        :rtype: str
+        :return: A string representation of this ``ProbDist``.
+        """
+        return "<MLEProbDist based on %d samples>" % self._freqdist.N()
+
+
+class LidstoneProbDist(ProbDistI):
+    """
+    The Lidstone estimate for the probability distribution of the
+    experiment used to generate a frequency distribution.  The
+    "Lidstone estimate" is parameterized by a real number *gamma*,
+    which typically ranges from 0 to 1.  The Lidstone estimate
+    approximates the probability of a sample with count *c* from an
+    experiment with *N* outcomes and *B* bins as
+    ``c+gamma)/(N+B*gamma)``.  This is equivalent to adding
+    *gamma* to the count for each bin, and taking the maximum
+    likelihood estimate of the resulting frequency distribution.
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, freqdist, gamma, bins=None):
+        """
+        Use the Lidstone estimate to create a probability distribution
+        for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        :type gamma: float
+        :param gamma: A real number used to parameterize the
+            estimate.  The Lidstone estimate is equivalent to adding
+            *gamma* to the count for each bin, and taking the
+            maximum likelihood estimate of the resulting frequency
+            distribution.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        if (bins == 0) or (bins is None and freqdist.N() == 0):
+            name = self.__class__.__name__[:-8]
+            raise ValueError(
+                "A %s probability distribution " % name + "must have at least one bin."
+            )
+        if (bins is not None) and (bins < freqdist.B()):
+            name = self.__class__.__name__[:-8]
+            raise ValueError(
+                "\nThe number of bins in a %s distribution " % name
+                + "(%d) must be greater than or equal to\n" % bins
+                + "the number of bins in the FreqDist used "
+                + "to create it (%d)." % freqdist.B()
+            )
+
+        self._freqdist = freqdist
+        self._gamma = float(gamma)
+        self._N = self._freqdist.N()
+
+        if bins is None:
+            bins = freqdist.B()
+        self._bins = bins
+
+        self._divisor = self._N + bins * gamma
+        if self._divisor == 0.0:
+            # In extreme cases we force the probability to be 0,
+            # which it will be, since the count will be 0:
+            self._gamma = 0
+            self._divisor = 1
+
+    def freqdist(self):
+        """
+        Return the frequency distribution that this probability
+        distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._freqdist
+
+    def prob(self, sample):
+        c = self._freqdist[sample]
+        return (c + self._gamma) / self._divisor
+
+    def max(self):
+        # For Lidstone distributions, probability is monotonic with
+        # frequency, so the most probable sample is the one that
+        # occurs most frequently.
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def discount(self):
+        gb = self._gamma * self._bins
+        return gb / (self._N + gb)
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<LidstoneProbDist based on %d samples>" % self._freqdist.N()
+
+
+class LaplaceProbDist(LidstoneProbDist):
+    """
+    The Laplace estimate for the probability distribution of the
+    experiment used to generate a frequency distribution.  The
+    "Laplace estimate" approximates the probability of a sample with
+    count *c* from an experiment with *N* outcomes and *B* bins as
+    *(c+1)/(N+B)*.  This is equivalent to adding one to the count for
+    each bin, and taking the maximum likelihood estimate of the
+    resulting frequency distribution.
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Use the Laplace estimate to create a probability distribution
+        for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        LidstoneProbDist.__init__(self, freqdist, 1, bins)
+
+    def __repr__(self):
+        """
+        :rtype: str
+        :return: A string representation of this ``ProbDist``.
+        """
+        return "<LaplaceProbDist based on %d samples>" % self._freqdist.N()
+
+
+class ELEProbDist(LidstoneProbDist):
+    """
+    The expected likelihood estimate for the probability distribution
+    of the experiment used to generate a frequency distribution.  The
+    "expected likelihood estimate" approximates the probability of a
+    sample with count *c* from an experiment with *N* outcomes and
+    *B* bins as *(c+0.5)/(N+B/2)*.  This is equivalent to adding 0.5
+    to the count for each bin, and taking the maximum likelihood
+    estimate of the resulting frequency distribution.
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Use the expected likelihood estimate to create a probability
+        distribution for the experiment used to generate ``freqdist``.
+
+        :type freqdist: FreqDist
+        :param freqdist: The frequency distribution that the
+            probability estimates should be based on.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        LidstoneProbDist.__init__(self, freqdist, 0.5, bins)
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<ELEProbDist based on %d samples>" % self._freqdist.N()
+
+
+class HeldoutProbDist(ProbDistI):
+    """
+    The heldout estimate for the probability distribution of the
+    experiment used to generate two frequency distributions.  These
+    two frequency distributions are called the "heldout frequency
+    distribution" and the "base frequency distribution."  The
+    "heldout estimate" uses uses the "heldout frequency
+    distribution" to predict the probability of each sample, given its
+    frequency in the "base frequency distribution".
+
+    In particular, the heldout estimate approximates the probability
+    for a sample that occurs *r* times in the base distribution as
+    the average frequency in the heldout distribution of all samples
+    that occur *r* times in the base distribution.
+
+    This average frequency is *Tr[r]/(Nr[r].N)*, where:
+
+    - *Tr[r]* is the total count in the heldout distribution for
+      all samples that occur *r* times in the base distribution.
+    - *Nr[r]* is the number of samples that occur *r* times in
+      the base distribution.
+    - *N* is the number of outcomes recorded by the heldout
+      frequency distribution.
+
+    In order to increase the efficiency of the ``prob`` member
+    function, *Tr[r]/(Nr[r].N)* is precomputed for each value of *r*
+    when the ``HeldoutProbDist`` is created.
+
+    :type _estimate: list(float)
+    :ivar _estimate: A list mapping from *r*, the number of
+        times that a sample occurs in the base distribution, to the
+        probability estimate for that sample.  ``_estimate[r]`` is
+        calculated by finding the average frequency in the heldout
+        distribution of all samples that occur *r* times in the base
+        distribution.  In particular, ``_estimate[r]`` =
+        *Tr[r]/(Nr[r].N)*.
+    :type _max_r: int
+    :ivar _max_r: The maximum number of times that any sample occurs
+        in the base distribution.  ``_max_r`` is used to decide how
+        large ``_estimate`` must be.
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, base_fdist, heldout_fdist, bins=None):
+        """
+        Use the heldout estimate to create a probability distribution
+        for the experiment used to generate ``base_fdist`` and
+        ``heldout_fdist``.
+
+        :type base_fdist: FreqDist
+        :param base_fdist: The base frequency distribution.
+        :type heldout_fdist: FreqDist
+        :param heldout_fdist: The heldout frequency distribution.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+
+        self._base_fdist = base_fdist
+        self._heldout_fdist = heldout_fdist
+
+        # The max number of times any sample occurs in base_fdist.
+        self._max_r = base_fdist[base_fdist.max()]
+
+        # Calculate Tr, Nr, and N.
+        Tr = self._calculate_Tr()
+        r_Nr = base_fdist.r_Nr(bins)
+        Nr = [r_Nr[r] for r in range(self._max_r + 1)]
+        N = heldout_fdist.N()
+
+        # Use Tr, Nr, and N to compute the probability estimate for
+        # each value of r.
+        self._estimate = self._calculate_estimate(Tr, Nr, N)
+
+    def _calculate_Tr(self):
+        """
+        Return the list *Tr*, where *Tr[r]* is the total count in
+        ``heldout_fdist`` for all samples that occur *r*
+        times in ``base_fdist``.
+
+        :rtype: list(float)
+        """
+        Tr = [0.0] * (self._max_r + 1)
+        for sample in self._heldout_fdist:
+            r = self._base_fdist[sample]
+            Tr[r] += self._heldout_fdist[sample]
+        return Tr
+
+    def _calculate_estimate(self, Tr, Nr, N):
+        """
+        Return the list *estimate*, where *estimate[r]* is the probability
+        estimate for any sample that occurs *r* times in the base frequency
+        distribution.  In particular, *estimate[r]* is *Tr[r]/(N[r].N)*.
+        In the special case that *N[r]=0*, *estimate[r]* will never be used;
+        so we define *estimate[r]=None* for those cases.
+
+        :rtype: list(float)
+        :type Tr: list(float)
+        :param Tr: the list *Tr*, where *Tr[r]* is the total count in
+            the heldout distribution for all samples that occur *r*
+            times in base distribution.
+        :type Nr: list(float)
+        :param Nr: The list *Nr*, where *Nr[r]* is the number of
+            samples that occur *r* times in the base distribution.
+        :type N: int
+        :param N: The total number of outcomes recorded by the heldout
+            frequency distribution.
+        """
+        estimate = []
+        for r in range(self._max_r + 1):
+            if Nr[r] == 0:
+                estimate.append(None)
+            else:
+                estimate.append(Tr[r] / (Nr[r] * N))
+        return estimate
+
+    def base_fdist(self):
+        """
+        Return the base frequency distribution that this probability
+        distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._base_fdist
+
+    def heldout_fdist(self):
+        """
+        Return the heldout frequency distribution that this
+        probability distribution is based on.
+
+        :rtype: FreqDist
+        """
+        return self._heldout_fdist
+
+    def samples(self):
+        return self._base_fdist.keys()
+
+    def prob(self, sample):
+        # Use our precomputed probability estimate.
+        r = self._base_fdist[sample]
+        return self._estimate[r]
+
+    def max(self):
+        # Note: the Heldout estimation is *not* necessarily monotonic;
+        # so this implementation is currently broken.  However, it
+        # should give the right answer *most* of the time. :)
+        return self._base_fdist.max()
+
+    def discount(self):
+        raise NotImplementedError()
+
+    def __repr__(self):
+        """
+        :rtype: str
+        :return: A string representation of this ``ProbDist``.
+        """
+        s = "<HeldoutProbDist: %d base samples; %d heldout samples>"
+        return s % (self._base_fdist.N(), self._heldout_fdist.N())
+
+
+class CrossValidationProbDist(ProbDistI):
+    """
+    The cross-validation estimate for the probability distribution of
+    the experiment used to generate a set of frequency distribution.
+    The "cross-validation estimate" for the probability of a sample
+    is found by averaging the held-out estimates for the sample in
+    each pair of frequency distributions.
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, freqdists, bins):
+        """
+        Use the cross-validation estimate to create a probability
+        distribution for the experiment used to generate
+        ``freqdists``.
+
+        :type freqdists: list(FreqDist)
+        :param freqdists: A list of the frequency distributions
+            generated by the experiment.
+        :type bins: int
+        :param bins: The number of sample values that can be generated
+            by the experiment that is described by the probability
+            distribution.  This value must be correctly set for the
+            probabilities of the sample values to sum to one.  If
+            ``bins`` is not specified, it defaults to ``freqdist.B()``.
+        """
+        self._freqdists = freqdists
+
+        # Create a heldout probability distribution for each pair of
+        # frequency distributions in freqdists.
+        self._heldout_probdists = []
+        for fdist1 in freqdists:
+            for fdist2 in freqdists:
+                if fdist1 is not fdist2:
+                    probdist = HeldoutProbDist(fdist1, fdist2, bins)
+                    self._heldout_probdists.append(probdist)
+
+    def freqdists(self):
+        """
+        Return the list of frequency distributions that this ``ProbDist`` is based on.
+
+        :rtype: list(FreqDist)
+        """
+        return self._freqdists
+
+    def samples(self):
+        # [xx] nb: this is not too efficient
+        return set(sum((list(fd) for fd in self._freqdists), []))
+
+    def prob(self, sample):
+        # Find the average probability estimate returned by each
+        # heldout distribution.
+        prob = 0.0
+        for heldout_probdist in self._heldout_probdists:
+            prob += heldout_probdist.prob(sample)
+        return prob / len(self._heldout_probdists)
+
+    def discount(self):
+        raise NotImplementedError()
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<CrossValidationProbDist: %d-way>" % len(self._freqdists)
+
+
+class WittenBellProbDist(ProbDistI):
+    """
+    The Witten-Bell estimate of a probability distribution. This distribution
+    allocates uniform probability mass to as yet unseen events by using the
+    number of events that have only been seen once. The probability mass
+    reserved for unseen events is equal to *T / (N + T)*
+    where *T* is the number of observed event types and *N* is the total
+    number of observed events. This equates to the maximum likelihood estimate
+    of a new type event occurring. The remaining probability mass is discounted
+    such that all probability estimates sum to one, yielding:
+
+        - *p = T / Z (N + T)*, if count = 0
+        - *p = c / (N + T)*, otherwise
+    """
+
+    def __init__(self, freqdist, bins=None):
+        """
+        Creates a distribution of Witten-Bell probability estimates.  This
+        distribution allocates uniform probability mass to as yet unseen
+        events by using the number of events that have only been seen once. The
+        probability mass reserved for unseen events is equal to *T / (N + T)*
+        where *T* is the number of observed event types and *N* is the total
+        number of observed events. This equates to the maximum likelihood
+        estimate of a new type event occurring. The remaining probability mass
+        is discounted such that all probability estimates sum to one,
+        yielding:
+
+            - *p = T / Z (N + T)*, if count = 0
+            - *p = c / (N + T)*, otherwise
+
+        The parameters *T* and *N* are taken from the ``freqdist`` parameter
+        (the ``B()`` and ``N()`` values). The normalizing factor *Z* is
+        calculated using these values along with the ``bins`` parameter.
+
+        :param freqdist: The frequency counts upon which to base the
+            estimation.
+        :type freqdist: FreqDist
+        :param bins: The number of possible event types. This must be at least
+            as large as the number of bins in the ``freqdist``. If None, then
+            it's assumed to be equal to that of the ``freqdist``
+        :type bins: int
+        """
+        assert bins is None or bins >= freqdist.B(), (
+            "bins parameter must not be less than %d=freqdist.B()" % freqdist.B()
+        )
+        if bins is None:
+            bins = freqdist.B()
+        self._freqdist = freqdist
+        self._T = self._freqdist.B()
+        self._Z = bins - self._freqdist.B()
+        self._N = self._freqdist.N()
+        # self._P0 is P(0), precalculated for efficiency:
+        if self._N == 0:
+            # if freqdist is empty, we approximate P(0) by a UniformProbDist:
+            self._P0 = 1.0 / self._Z
+        else:
+            self._P0 = self._T / (self._Z * (self._N + self._T))
+
+    def prob(self, sample):
+        # inherit docs from ProbDistI
+        c = self._freqdist[sample]
+        return c / (self._N + self._T) if c != 0 else self._P0
+
+    def max(self):
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def freqdist(self):
+        return self._freqdist
+
+    def discount(self):
+        raise NotImplementedError()
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<WittenBellProbDist based on %d samples>" % self._freqdist.N()
+
+
+##//////////////////////////////////////////////////////
+##  Good-Turing Probability Distributions
+##//////////////////////////////////////////////////////
+
+# Good-Turing frequency estimation was contributed by Alan Turing and
+# his statistical assistant I.J. Good, during their collaboration in
+# the WWII.  It is a statistical technique for predicting the
+# probability of occurrence of objects belonging to an unknown number
+# of species, given past observations of such objects and their
+# species. (In drawing balls from an urn, the 'objects' would be balls
+# and the 'species' would be the distinct colors of the balls (finite
+# but unknown in number).
+#
+# Good-Turing method calculates the probability mass to assign to
+# events with zero or low counts based on the number of events with
+# higher counts. It does so by using the adjusted count *c\**:
+#
+#     - *c\* = (c + 1) N(c + 1) / N(c)*   for c >= 1
+#     - *things with frequency zero in training* = N(1)  for c == 0
+#
+# where *c* is the original count, *N(i)* is the number of event types
+# observed with count *i*. We can think the count of unseen as the count
+# of frequency one (see Jurafsky & Martin 2nd Edition, p101).
+#
+# This method is problematic because the situation ``N(c+1) == 0``
+# is quite common in the original Good-Turing estimation; smoothing or
+# interpolation of *N(i)* values is essential in practice.
+#
+# Bill Gale and Geoffrey Sampson present a simple and effective approach,
+# Simple Good-Turing.  As a smoothing curve they simply use a power curve:
+#
+#     Nr = a*r^b (with b < -1 to give the appropriate hyperbolic
+#     relationship)
+#
+# They estimate a and b by simple linear regression technique on the
+# logarithmic form of the equation:
+#
+#     log Nr = a + b*log(r)
+#
+# However, they suggest that such a simple curve is probably only
+# appropriate for high values of r. For low values of r, they use the
+# measured Nr directly.  (see M&S, p.213)
+#
+# Gale and Sampson propose to use r while the difference between r and
+# r* is 1.96 greater than the standard deviation, and switch to r* if
+# it is less or equal:
+#
+#     |r - r*| > 1.96 * sqrt((r + 1)^2 (Nr+1 / Nr^2) (1 + Nr+1 / Nr))
+#
+# The 1.96 coefficient correspond to a 0.05 significance criterion,
+# some implementations can use a coefficient of 1.65 for a 0.1
+# significance criterion.
+#
+
+##//////////////////////////////////////////////////////
+##  Simple Good-Turing Probablity Distributions
+##//////////////////////////////////////////////////////
+
+
+class SimpleGoodTuringProbDist(ProbDistI):
+    """
+    SimpleGoodTuring ProbDist approximates from frequency to frequency of
+    frequency into a linear line under log space by linear regression.
+    Details of Simple Good-Turing algorithm can be found in:
+
+    - Good Turing smoothing without tears" (Gale & Sampson 1995),
+      Journal of Quantitative Linguistics, vol. 2 pp. 217-237.
+    - "Speech and Language Processing (Jurafsky & Martin),
+      2nd Edition, Chapter 4.5 p103 (log(Nc) =  a + b*log(c))
+    - https://www.grsampson.net/RGoodTur.html
+
+    Given a set of pair (xi, yi),  where the xi denotes the frequency and
+    yi denotes the frequency of frequency, we want to minimize their
+    square variation. E(x) and E(y) represent the mean of xi and yi.
+
+    - slope: b = sigma ((xi-E(x)(yi-E(y))) / sigma ((xi-E(x))(xi-E(x)))
+    - intercept: a = E(y) - b.E(x)
+    """
+
+    SUM_TO_ONE = False
+
+    def __init__(self, freqdist, bins=None):
+        """
+        :param freqdist: The frequency counts upon which to base the
+            estimation.
+        :type freqdist: FreqDist
+        :param bins: The number of possible event types. This must be
+            larger than the number of bins in the ``freqdist``. If None,
+            then it's assumed to be equal to ``freqdist``.B() + 1
+        :type bins: int
+        """
+        assert (
+            bins is None or bins > freqdist.B()
+        ), "bins parameter must not be less than %d=freqdist.B()+1" % (freqdist.B() + 1)
+        if bins is None:
+            bins = freqdist.B() + 1
+        self._freqdist = freqdist
+        self._bins = bins
+        r, nr = self._r_Nr()
+        self.find_best_fit(r, nr)
+        self._switch(r, nr)
+        self._renormalize(r, nr)
+
+    def _r_Nr_non_zero(self):
+        r_Nr = self._freqdist.r_Nr()
+        del r_Nr[0]
+        return r_Nr
+
+    def _r_Nr(self):
+        """
+        Split the frequency distribution in two list (r, Nr), where Nr(r) > 0
+        """
+        nonzero = self._r_Nr_non_zero()
+
+        if not nonzero:
+            return [], []
+        return zip(*sorted(nonzero.items()))
+
+    def find_best_fit(self, r, nr):
+        """
+        Use simple linear regression to tune parameters self._slope and
+        self._intercept in the log-log space based on count and Nr(count)
+        (Work in log space to avoid floating point underflow.)
+        """
+        # For higher sample frequencies the data points becomes horizontal
+        # along line Nr=1. To create a more evident linear model in log-log
+        # space, we average positive Nr values with the surrounding zero
+        # values. (Church and Gale, 1991)
+
+        if not r or not nr:
+            # Empty r or nr?
+            return
+
+        zr = []
+        for j in range(len(r)):
+            i = r[j - 1] if j > 0 else 0
+            k = 2 * r[j] - i if j == len(r) - 1 else r[j + 1]
+            zr_ = 2.0 * nr[j] / (k - i)
+            zr.append(zr_)
+
+        log_r = [math.log(i) for i in r]
+        log_zr = [math.log(i) for i in zr]
+
+        xy_cov = x_var = 0.0
+        x_mean = sum(log_r) / len(log_r)
+        y_mean = sum(log_zr) / len(log_zr)
+        for (x, y) in zip(log_r, log_zr):
+            xy_cov += (x - x_mean) * (y - y_mean)
+            x_var += (x - x_mean) ** 2
+        self._slope = xy_cov / x_var if x_var != 0 else 0.0
+        if self._slope >= -1:
+            warnings.warn(
+                "SimpleGoodTuring did not find a proper best fit "
+                "line for smoothing probabilities of occurrences. "
+                "The probability estimates are likely to be "
+                "unreliable."
+            )
+        self._intercept = y_mean - self._slope * x_mean
+
+    def _switch(self, r, nr):
+        """
+        Calculate the r frontier where we must switch from Nr to Sr
+        when estimating E[Nr].
+        """
+        for i, r_ in enumerate(r):
+            if len(r) == i + 1 or r[i + 1] != r_ + 1:
+                # We are at the end of r, or there is a gap in r
+                self._switch_at = r_
+                break
+
+            Sr = self.smoothedNr
+            smooth_r_star = (r_ + 1) * Sr(r_ + 1) / Sr(r_)
+            unsmooth_r_star = (r_ + 1) * nr[i + 1] / nr[i]
+
+            std = math.sqrt(self._variance(r_, nr[i], nr[i + 1]))
+            if abs(unsmooth_r_star - smooth_r_star) <= 1.96 * std:
+                self._switch_at = r_
+                break
+
+    def _variance(self, r, nr, nr_1):
+        r = float(r)
+        nr = float(nr)
+        nr_1 = float(nr_1)
+        return (r + 1.0) ** 2 * (nr_1 / nr**2) * (1.0 + nr_1 / nr)
+
+    def _renormalize(self, r, nr):
+        """
+        It is necessary to renormalize all the probability estimates to
+        ensure a proper probability distribution results. This can be done
+        by keeping the estimate of the probability mass for unseen items as
+        N(1)/N and renormalizing all the estimates for previously seen items
+        (as Gale and Sampson (1995) propose). (See M&S P.213, 1999)
+        """
+        prob_cov = 0.0
+        for r_, nr_ in zip(r, nr):
+            prob_cov += nr_ * self._prob_measure(r_)
+        if prob_cov:
+            self._renormal = (1 - self._prob_measure(0)) / prob_cov
+
+    def smoothedNr(self, r):
+        """
+        Return the number of samples with count r.
+
+        :param r: The amount of frequency.
+        :type r: int
+        :rtype: float
+        """
+
+        # Nr = a*r^b (with b < -1 to give the appropriate hyperbolic
+        # relationship)
+        # Estimate a and b by simple linear regression technique on
+        # the logarithmic form of the equation: log Nr = a + b*log(r)
+
+        return math.exp(self._intercept + self._slope * math.log(r))
+
+    def prob(self, sample):
+        """
+        Return the sample's probability.
+
+        :param sample: sample of the event
+        :type sample: str
+        :rtype: float
+        """
+        count = self._freqdist[sample]
+        p = self._prob_measure(count)
+        if count == 0:
+            if self._bins == self._freqdist.B():
+                p = 0.0
+            else:
+                p = p / (self._bins - self._freqdist.B())
+        else:
+            p = p * self._renormal
+        return p
+
+    def _prob_measure(self, count):
+        if count == 0 and self._freqdist.N() == 0:
+            return 1.0
+        elif count == 0 and self._freqdist.N() != 0:
+            return self._freqdist.Nr(1) / self._freqdist.N()
+
+        if self._switch_at > count:
+            Er_1 = self._freqdist.Nr(count + 1)
+            Er = self._freqdist.Nr(count)
+        else:
+            Er_1 = self.smoothedNr(count + 1)
+            Er = self.smoothedNr(count)
+
+        r_star = (count + 1) * Er_1 / Er
+        return r_star / self._freqdist.N()
+
+    def check(self):
+        prob_sum = 0.0
+        for i in range(0, len(self._Nr)):
+            prob_sum += self._Nr[i] * self._prob_measure(i) / self._renormal
+        print("Probability Sum:", prob_sum)
+        # assert prob_sum != 1.0, "probability sum should be one!"
+
+    def discount(self):
+        """
+        This function returns the total mass of probability transfers from the
+        seen samples to the unseen samples.
+        """
+        return self.smoothedNr(1) / self._freqdist.N()
+
+    def max(self):
+        return self._freqdist.max()
+
+    def samples(self):
+        return self._freqdist.keys()
+
+    def freqdist(self):
+        return self._freqdist
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ProbDist``.
+
+        :rtype: str
+        """
+        return "<SimpleGoodTuringProbDist based on %d samples>" % self._freqdist.N()
+
+
+class MutableProbDist(ProbDistI):
+    """
+    An mutable probdist where the probabilities may be easily modified. This
+    simply copies an existing probdist, storing the probability values in a
+    mutable dictionary and providing an update method.
+    """
+
+    def __init__(self, prob_dist, samples, store_logs=True):
+        """
+        Creates the mutable probdist based on the given prob_dist and using
+        the list of samples given. These values are stored as log
+        probabilities if the store_logs flag is set.
+
+        :param prob_dist: the distribution from which to garner the
+            probabilities
+        :type prob_dist: ProbDist
+        :param samples: the complete set of samples
+        :type samples: sequence of any
+        :param store_logs: whether to store the probabilities as logarithms
+        :type store_logs: bool
+        """
+        self._samples = samples
+        self._sample_dict = {samples[i]: i for i in range(len(samples))}
+        self._data = array.array("d", [0.0]) * len(samples)
+        for i in range(len(samples)):
+            if store_logs:
+                self._data[i] = prob_dist.logprob(samples[i])
+            else:
+                self._data[i] = prob_dist.prob(samples[i])
+        self._logs = store_logs
+
+    def max(self):
+        # inherit documentation
+        return max((p, v) for (v, p) in self._sample_dict.items())[1]
+
+    def samples(self):
+        # inherit documentation
+        return self._samples
+
+    def prob(self, sample):
+        # inherit documentation
+        i = self._sample_dict.get(sample)
+        if i is None:
+            return 0.0
+        return 2 ** (self._data[i]) if self._logs else self._data[i]
+
+    def logprob(self, sample):
+        # inherit documentation
+        i = self._sample_dict.get(sample)
+        if i is None:
+            return float("-inf")
+        return self._data[i] if self._logs else math.log(self._data[i], 2)
+
+    def update(self, sample, prob, log=True):
+        """
+        Update the probability for the given sample. This may cause the object
+        to stop being the valid probability distribution - the user must
+        ensure that they update the sample probabilities such that all samples
+        have probabilities between 0 and 1 and that all probabilities sum to
+        one.
+
+        :param sample: the sample for which to update the probability
+        :type sample: any
+        :param prob: the new probability
+        :type prob: float
+        :param log: is the probability already logged
+        :type log: bool
+        """
+        i = self._sample_dict.get(sample)
+        assert i is not None
+        if self._logs:
+            self._data[i] = prob if log else math.log(prob, 2)
+        else:
+            self._data[i] = 2 ** (prob) if log else prob
+
+
+##/////////////////////////////////////////////////////
+##  Kneser-Ney Probability Distribution
+##//////////////////////////////////////////////////////
+
+# This method for calculating probabilities was introduced in 1995 by Reinhard
+# Kneser and Hermann Ney. It was meant to improve the accuracy of language
+# models that use backing-off to deal with sparse data. The authors propose two
+# ways of doing so: a marginal distribution constraint on the back-off
+# distribution and a leave-one-out distribution. For a start, the first one is
+# implemented as a class below.
+#
+# The idea behind a back-off n-gram model is that we have a series of
+# frequency distributions for our n-grams so that in case we have not seen a
+# given n-gram during training (and as a result have a 0 probability for it) we
+# can 'back off' (hence the name!) and try testing whether we've seen the
+# n-1-gram part of the n-gram in training.
+#
+# The novelty of Kneser and Ney's approach was that they decided to fiddle
+# around with the way this latter, backed off probability was being calculated
+# whereas their peers seemed to focus on the primary probability.
+#
+# The implementation below uses one of the techniques described in their paper
+# titled "Improved backing-off for n-gram language modeling." In the same paper
+# another technique is introduced to attempt to smooth the back-off
+# distribution as well as the primary one. There is also a much-cited
+# modification of this method proposed by Chen and Goodman.
+#
+# In order for the implementation of Kneser-Ney to be more efficient, some
+# changes have been made to the original algorithm. Namely, the calculation of
+# the normalizing function gamma has been significantly simplified and
+# combined slightly differently with beta. None of these changes affect the
+# nature of the algorithm, but instead aim to cut out unnecessary calculations
+# and take advantage of storing and retrieving information in dictionaries
+# where possible.
+
+
+class KneserNeyProbDist(ProbDistI):
+    """
+    Kneser-Ney estimate of a probability distribution. This is a version of
+    back-off that counts how likely an n-gram is provided the n-1-gram had
+    been seen in training. Extends the ProbDistI interface, requires a trigram
+    FreqDist instance to train on. Optionally, a different from default discount
+    value can be specified. The default discount is set to 0.75.
+
+    """
+
+    def __init__(self, freqdist, bins=None, discount=0.75):
+        """
+        :param freqdist: The trigram frequency distribution upon which to base
+            the estimation
+        :type freqdist: FreqDist
+        :param bins: Included for compatibility with nltk.tag.hmm
+        :type bins: int or float
+        :param discount: The discount applied when retrieving counts of
+            trigrams
+        :type discount: float (preferred, but can be set to int)
+        """
+
+        if not bins:
+            self._bins = freqdist.B()
+        else:
+            self._bins = bins
+        self._D = discount
+
+        # cache for probability calculation
+        self._cache = {}
+
+        # internal bigram and trigram frequency distributions
+        self._bigrams = defaultdict(int)
+        self._trigrams = freqdist
+
+        # helper dictionaries used to calculate probabilities
+        self._wordtypes_after = defaultdict(float)
+        self._trigrams_contain = defaultdict(float)
+        self._wordtypes_before = defaultdict(float)
+        for w0, w1, w2 in freqdist:
+            self._bigrams[(w0, w1)] += freqdist[(w0, w1, w2)]
+            self._wordtypes_after[(w0, w1)] += 1
+            self._trigrams_contain[w1] += 1
+            self._wordtypes_before[(w1, w2)] += 1
+
+    def prob(self, trigram):
+        # sample must be a triple
+        if len(trigram) != 3:
+            raise ValueError("Expected an iterable with 3 members.")
+        trigram = tuple(trigram)
+        w0, w1, w2 = trigram
+
+        if trigram in self._cache:
+            return self._cache[trigram]
+        else:
+            # if the sample trigram was seen during training
+            if trigram in self._trigrams:
+                prob = (self._trigrams[trigram] - self.discount()) / self._bigrams[
+                    (w0, w1)
+                ]
+
+            # else if the 'rougher' environment was seen during training
+            elif (w0, w1) in self._bigrams and (w1, w2) in self._wordtypes_before:
+                aftr = self._wordtypes_after[(w0, w1)]
+                bfr = self._wordtypes_before[(w1, w2)]
+
+                # the probability left over from alphas
+                leftover_prob = (aftr * self.discount()) / self._bigrams[(w0, w1)]
+
+                # the beta (including normalization)
+                beta = bfr / (self._trigrams_contain[w1] - aftr)
+
+                prob = leftover_prob * beta
+
+            # else the sample was completely unseen during training
+            else:
+                prob = 0.0
+
+            self._cache[trigram] = prob
+            return prob
+
+    def discount(self):
+        """
+        Return the value by which counts are discounted. By default set to 0.75.
+
+        :rtype: float
+        """
+        return self._D
+
+    def set_discount(self, discount):
+        """
+        Set the value by which counts are discounted to the value of discount.
+
+        :param discount: the new value to discount counts by
+        :type discount: float (preferred, but int possible)
+        :rtype: None
+        """
+        self._D = discount
+
+    def samples(self):
+        return self._trigrams.keys()
+
+    def max(self):
+        return self._trigrams.max()
+
+    def __repr__(self):
+        """
+        Return a string representation of this ProbDist
+
+        :rtype: str
+        """
+        return f"<KneserNeyProbDist based on {self._trigrams.N()} trigrams"
+
+
+##//////////////////////////////////////////////////////
+##  Probability Distribution Operations
+##//////////////////////////////////////////////////////
+
+
+def log_likelihood(test_pdist, actual_pdist):
+    if not isinstance(test_pdist, ProbDistI) or not isinstance(actual_pdist, ProbDistI):
+        raise ValueError("expected a ProbDist.")
+    # Is this right?
+    return sum(
+        actual_pdist.prob(s) * math.log(test_pdist.prob(s), 2) for s in actual_pdist
+    )
+
+
+def entropy(pdist):
+    probs = (pdist.prob(s) for s in pdist.samples())
+    return -sum(p * math.log(p, 2) for p in probs)
+
+
+##//////////////////////////////////////////////////////
+##  Conditional Distributions
+##//////////////////////////////////////////////////////
+
+
+class ConditionalFreqDist(defaultdict):
+    """
+    A collection of frequency distributions for a single experiment
+    run under different conditions.  Conditional frequency
+    distributions are used to record the number of times each sample
+    occurred, given the condition under which the experiment was run.
+    For example, a conditional frequency distribution could be used to
+    record the frequency of each word (type) in a document, given its
+    length.  Formally, a conditional frequency distribution can be
+    defined as a function that maps from each condition to the
+    FreqDist for the experiment under that condition.
+
+    Conditional frequency distributions are typically constructed by
+    repeatedly running an experiment under a variety of conditions,
+    and incrementing the sample outcome counts for the appropriate
+    conditions.  For example, the following code will produce a
+    conditional frequency distribution that encodes how often each
+    word type occurs, given the length of that word type:
+
+        >>> from nltk.probability import ConditionalFreqDist
+        >>> from nltk.tokenize import word_tokenize
+        >>> sent = "the the the dog dog some other words that we do not care about"
+        >>> cfdist = ConditionalFreqDist()
+        >>> for word in word_tokenize(sent):
+        ...     condition = len(word)
+        ...     cfdist[condition][word] += 1
+
+    An equivalent way to do this is with the initializer:
+
+        >>> cfdist = ConditionalFreqDist((len(word), word) for word in word_tokenize(sent))
+
+    The frequency distribution for each condition is accessed using
+    the indexing operator:
+
+        >>> cfdist[3]
+        FreqDist({'the': 3, 'dog': 2, 'not': 1})
+        >>> cfdist[3].freq('the')
+        0.5
+        >>> cfdist[3]['dog']
+        2
+
+    When the indexing operator is used to access the frequency
+    distribution for a condition that has not been accessed before,
+    ``ConditionalFreqDist`` creates a new empty FreqDist for that
+    condition.
+
+    """
+
+    def __init__(self, cond_samples=None):
+        """
+        Construct a new empty conditional frequency distribution.  In
+        particular, the count for every sample, under every condition,
+        is zero.
+
+        :param cond_samples: The samples to initialize the conditional
+            frequency distribution with
+        :type cond_samples: Sequence of (condition, sample) tuples
+        """
+        defaultdict.__init__(self, FreqDist)
+
+        if cond_samples:
+            for (cond, sample) in cond_samples:
+                self[cond][sample] += 1
+
+    def __reduce__(self):
+        kv_pairs = ((cond, self[cond]) for cond in self.conditions())
+        return (self.__class__, (), None, None, kv_pairs)
+
+    def conditions(self):
+        """
+        Return a list of the conditions that have been accessed for
+        this ``ConditionalFreqDist``.  Use the indexing operator to
+        access the frequency distribution for a given condition.
+        Note that the frequency distributions for some conditions
+        may contain zero sample outcomes.
+
+        :rtype: list
+        """
+        return list(self.keys())
+
+    def N(self):
+        """
+        Return the total number of sample outcomes that have been
+        recorded by this ``ConditionalFreqDist``.
+
+        :rtype: int
+        """
+        return sum(fdist.N() for fdist in self.values())
+
+    def plot(
+        self,
+        *args,
+        samples=None,
+        title="",
+        cumulative=False,
+        percents=False,
+        conditions=None,
+        show=True,
+        **kwargs,
+    ):
+        """
+        Plot the given samples from the conditional frequency distribution.
+        For a cumulative plot, specify cumulative=True. Additional ``*args`` and
+        ``**kwargs`` are passed to matplotlib's plot function.
+        (Requires Matplotlib to be installed.)
+
+        :param samples: The samples to plot
+        :type samples: list
+        :param title: The title for the graph
+        :type title: str
+        :param cumulative: Whether the plot is cumulative. (default = False)
+        :type cumulative: bool
+        :param percents: Whether the plot uses percents instead of counts. (default = False)
+        :type percents: bool
+        :param conditions: The conditions to plot (default is all)
+        :type conditions: list
+        :param show: Whether to show the plot, or only return the ax.
+        :type show: bool
+        """
+        try:
+            import matplotlib.pyplot as plt  # import statement fix
+        except ImportError as e:
+            raise ValueError(
+                "The plot function requires matplotlib to be installed."
+                "See https://matplotlib.org/"
+            ) from e
+
+        if not conditions:
+            conditions = self.conditions()
+        else:
+            conditions = [c for c in conditions if c in self]
+        if not samples:
+            samples = sorted({v for c in conditions for v in self[c]})
+        if "linewidth" not in kwargs:
+            kwargs["linewidth"] = 2
+        ax = plt.gca()
+        if conditions:
+            freqs = []
+            for condition in conditions:
+                if cumulative:
+                    # freqs should be a list of list where each sub list will be a frequency of a condition
+                    freq = list(self[condition]._cumulative_frequencies(samples))
+                else:
+                    freq = [self[condition][sample] for sample in samples]
+
+                if percents:
+                    freq = [f / self[condition].N() * 100 for f in freq]
+
+                freqs.append(freq)
+
+            if cumulative:
+                ylabel = "Cumulative "
+                legend_loc = "lower right"
+            else:
+                ylabel = ""
+                legend_loc = "upper right"
+
+            if percents:
+                ylabel += "Percents"
+            else:
+                ylabel += "Counts"
+
+            i = 0
+            for freq in freqs:
+                kwargs["label"] = conditions[i]  # label for each condition
+                i += 1
+                ax.plot(freq, *args, **kwargs)
+            ax.legend(loc=legend_loc)
+            ax.grid(True, color="silver")
+            ax.set_xticks(range(len(samples)))
+            ax.set_xticklabels([str(s) for s in samples], rotation=90)
+            if title:
+                ax.set_title(title)
+            ax.set_xlabel("Samples")
+            ax.set_ylabel(ylabel)
+
+        if show:
+            plt.show()
+
+        return ax
+
+    def tabulate(self, *args, **kwargs):
+        """
+        Tabulate the given samples from the conditional frequency distribution.
+
+        :param samples: The samples to plot
+        :type samples: list
+        :param conditions: The conditions to plot (default is all)
+        :type conditions: list
+        :param cumulative: A flag to specify whether the freqs are cumulative (default = False)
+        :type title: bool
+        """
+
+        cumulative = _get_kwarg(kwargs, "cumulative", False)
+        conditions = _get_kwarg(kwargs, "conditions", sorted(self.conditions()))
+        samples = _get_kwarg(
+            kwargs,
+            "samples",
+            sorted({v for c in conditions if c in self for v in self[c]}),
+        )  # this computation could be wasted
+
+        width = max(len("%s" % s) for s in samples)
+        freqs = dict()
+        for c in conditions:
+            if cumulative:
+                freqs[c] = list(self[c]._cumulative_frequencies(samples))
+            else:
+                freqs[c] = [self[c][sample] for sample in samples]
+            width = max(width, max(len("%d" % f) for f in freqs[c]))
+
+        condition_size = max(len("%s" % c) for c in conditions)
+        print(" " * condition_size, end=" ")
+        for s in samples:
+            print("%*s" % (width, s), end=" ")
+        print()
+        for c in conditions:
+            print("%*s" % (condition_size, c), end=" ")
+            for f in freqs[c]:
+                print("%*d" % (width, f), end=" ")
+            print()
+
+    # Mathematical operators
+
+    def __add__(self, other):
+        """
+        Add counts from two ConditionalFreqDists.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = self.copy()
+        for cond in other.conditions():
+            result[cond] += other[cond]
+        return result
+
+    def __sub__(self, other):
+        """
+        Subtract count, but keep only results with positive counts.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = self.copy()
+        for cond in other.conditions():
+            result[cond] -= other[cond]
+            if not result[cond]:
+                del result[cond]
+        return result
+
+    def __or__(self, other):
+        """
+        Union is the maximum of value in either of the input counters.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = self.copy()
+        for cond in other.conditions():
+            result[cond] |= other[cond]
+        return result
+
+    def __and__(self, other):
+        """
+        Intersection is the minimum of corresponding counts.
+        """
+        if not isinstance(other, ConditionalFreqDist):
+            return NotImplemented
+        result = ConditionalFreqDist()
+        for cond in self.conditions():
+            newfreqdist = self[cond] & other[cond]
+            if newfreqdist:
+                result[cond] = newfreqdist
+        return result
+
+    # @total_ordering doesn't work here, since the class inherits from a builtin class
+    def __le__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types("<=", self, other)
+        return set(self.conditions()).issubset(other.conditions()) and all(
+            self[c] <= other[c] for c in self.conditions()
+        )
+
+    def __lt__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types("<", self, other)
+        return self <= other and self != other
+
+    def __ge__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types(">=", self, other)
+        return other <= self
+
+    def __gt__(self, other):
+        if not isinstance(other, ConditionalFreqDist):
+            raise_unorderable_types(">", self, other)
+        return other < self
+
+    def deepcopy(self):
+        from copy import deepcopy
+
+        return deepcopy(self)
+
+    copy = deepcopy
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ConditionalFreqDist``.
+
+        :rtype: str
+        """
+        return "<ConditionalFreqDist with %d conditions>" % len(self)
+
+
+class ConditionalProbDistI(dict, metaclass=ABCMeta):
+    """
+    A collection of probability distributions for a single experiment
+    run under different conditions.  Conditional probability
+    distributions are used to estimate the likelihood of each sample,
+    given the condition under which the experiment was run.  For
+    example, a conditional probability distribution could be used to
+    estimate the probability of each word type in a document, given
+    the length of the word type.  Formally, a conditional probability
+    distribution can be defined as a function that maps from each
+    condition to the ``ProbDist`` for the experiment under that
+    condition.
+    """
+
+    @abstractmethod
+    def __init__(self):
+        """
+        Classes inheriting from ConditionalProbDistI should implement __init__.
+        """
+
+    def conditions(self):
+        """
+        Return a list of the conditions that are represented by
+        this ``ConditionalProbDist``.  Use the indexing operator to
+        access the probability distribution for a given condition.
+
+        :rtype: list
+        """
+        return list(self.keys())
+
+    def __repr__(self):
+        """
+        Return a string representation of this ``ConditionalProbDist``.
+
+        :rtype: str
+        """
+        return "<%s with %d conditions>" % (type(self).__name__, len(self))
+
+
+class ConditionalProbDist(ConditionalProbDistI):
+    """
+    A conditional probability distribution modeling the experiments
+    that were used to generate a conditional frequency distribution.
+    A ConditionalProbDist is constructed from a
+    ``ConditionalFreqDist`` and a ``ProbDist`` factory:
+
+    - The ``ConditionalFreqDist`` specifies the frequency
+      distribution for each condition.
+    - The ``ProbDist`` factory is a function that takes a
+      condition's frequency distribution, and returns its
+      probability distribution.  A ``ProbDist`` class's name (such as
+      ``MLEProbDist`` or ``HeldoutProbDist``) can be used to specify
+      that class's constructor.
+
+    The first argument to the ``ProbDist`` factory is the frequency
+    distribution that it should model; and the remaining arguments are
+    specified by the ``factory_args`` parameter to the
+    ``ConditionalProbDist`` constructor.  For example, the following
+    code constructs a ``ConditionalProbDist``, where the probability
+    distribution for each condition is an ``ELEProbDist`` with 10 bins:
+
+        >>> from nltk.corpus import brown
+        >>> from nltk.probability import ConditionalFreqDist
+        >>> from nltk.probability import ConditionalProbDist, ELEProbDist
+        >>> cfdist = ConditionalFreqDist(brown.tagged_words()[:5000])
+        >>> cpdist = ConditionalProbDist(cfdist, ELEProbDist, 10)
+        >>> cpdist['passed'].max()
+        'VBD'
+        >>> cpdist['passed'].prob('VBD') #doctest: +ELLIPSIS
+        0.423...
+
+    """
+
+    def __init__(self, cfdist, probdist_factory, *factory_args, **factory_kw_args):
+        """
+        Construct a new conditional probability distribution, based on
+        the given conditional frequency distribution and ``ProbDist``
+        factory.
+
+        :type cfdist: ConditionalFreqDist
+        :param cfdist: The ``ConditionalFreqDist`` specifying the
+            frequency distribution for each condition.
+        :type probdist_factory: class or function
+        :param probdist_factory: The function or class that maps
+            a condition's frequency distribution to its probability
+            distribution.  The function is called with the frequency
+            distribution as its first argument,
+            ``factory_args`` as its remaining arguments, and
+            ``factory_kw_args`` as keyword arguments.
+        :type factory_args: (any)
+        :param factory_args: Extra arguments for ``probdist_factory``.
+            These arguments are usually used to specify extra
+            properties for the probability distributions of individual
+            conditions, such as the number of bins they contain.
+        :type factory_kw_args: (any)
+        :param factory_kw_args: Extra keyword arguments for ``probdist_factory``.
+        """
+        self._probdist_factory = probdist_factory
+        self._factory_args = factory_args
+        self._factory_kw_args = factory_kw_args
+
+        for condition in cfdist:
+            self[condition] = probdist_factory(
+                cfdist[condition], *factory_args, **factory_kw_args
+            )
+
+    def __missing__(self, key):
+        self[key] = self._probdist_factory(
+            FreqDist(), *self._factory_args, **self._factory_kw_args
+        )
+        return self[key]
+
+
+class DictionaryConditionalProbDist(ConditionalProbDistI):
+    """
+    An alternative ConditionalProbDist that simply wraps a dictionary of
+    ProbDists rather than creating these from FreqDists.
+    """
+
+    def __init__(self, probdist_dict):
+        """
+        :param probdist_dict: a dictionary containing the probdists indexed
+            by the conditions
+        :type probdist_dict: dict any -> probdist
+        """
+        self.update(probdist_dict)
+
+    def __missing__(self, key):
+        self[key] = DictionaryProbDist()
+        return self[key]
+
+
+##//////////////////////////////////////////////////////
+## Adding in log-space.
+##//////////////////////////////////////////////////////
+
+# If the difference is bigger than this, then just take the bigger one:
+_ADD_LOGS_MAX_DIFF = math.log(1e-30, 2)
+
+
+def add_logs(logx, logy):
+    """
+    Given two numbers ``logx`` = *log(x)* and ``logy`` = *log(y)*, return
+    *log(x+y)*.  Conceptually, this is the same as returning
+    ``log(2**(logx)+2**(logy))``, but the actual implementation
+    avoids overflow errors that could result from direct computation.
+    """
+    if logx < logy + _ADD_LOGS_MAX_DIFF:
+        return logy
+    if logy < logx + _ADD_LOGS_MAX_DIFF:
+        return logx
+    base = min(logx, logy)
+    return base + math.log(2 ** (logx - base) + 2 ** (logy - base), 2)
+
+
+def sum_logs(logs):
+    return reduce(add_logs, logs[1:], logs[0]) if len(logs) != 0 else _NINF
+
+
+##//////////////////////////////////////////////////////
+##  Probabilistic Mix-in
+##//////////////////////////////////////////////////////
+
+
+class ProbabilisticMixIn:
+    """
+    A mix-in class to associate probabilities with other classes
+    (trees, rules, etc.).  To use the ``ProbabilisticMixIn`` class,
+    define a new class that derives from an existing class and from
+    ProbabilisticMixIn.  You will need to define a new constructor for
+    the new class, which explicitly calls the constructors of both its
+    parent classes.  For example:
+
+        >>> from nltk.probability import ProbabilisticMixIn
+        >>> class A:
+        ...     def __init__(self, x, y): self.data = (x,y)
+        ...
+        >>> class ProbabilisticA(A, ProbabilisticMixIn):
+        ...     def __init__(self, x, y, **prob_kwarg):
+        ...         A.__init__(self, x, y)
+        ...         ProbabilisticMixIn.__init__(self, **prob_kwarg)
+
+    See the documentation for the ProbabilisticMixIn
+    ``constructor<__init__>`` for information about the arguments it
+    expects.
+
+    You should generally also redefine the string representation
+    methods, the comparison methods, and the hashing method.
+    """
+
+    def __init__(self, **kwargs):
+        """
+        Initialize this object's probability.  This initializer should
+        be called by subclass constructors.  ``prob`` should generally be
+        the first argument for those constructors.
+
+        :param prob: The probability associated with the object.
+        :type prob: float
+        :param logprob: The log of the probability associated with
+            the object.
+        :type logprob: float
+        """
+        if "prob" in kwargs:
+            if "logprob" in kwargs:
+                raise TypeError("Must specify either prob or logprob " "(not both)")
+            else:
+                ProbabilisticMixIn.set_prob(self, kwargs["prob"])
+        elif "logprob" in kwargs:
+            ProbabilisticMixIn.set_logprob(self, kwargs["logprob"])
+        else:
+            self.__prob = self.__logprob = None
+
+    def set_prob(self, prob):
+        """
+        Set the probability associated with this object to ``prob``.
+
+        :param prob: The new probability
+        :type prob: float
+        """
+        self.__prob = prob
+        self.__logprob = None
+
+    def set_logprob(self, logprob):
+        """
+        Set the log probability associated with this object to
+        ``logprob``.  I.e., set the probability associated with this
+        object to ``2**(logprob)``.
+
+        :param logprob: The new log probability
+        :type logprob: float
+        """
+        self.__logprob = logprob
+        self.__prob = None
+
+    def prob(self):
+        """
+        Return the probability associated with this object.
+
+        :rtype: float
+        """
+        if self.__prob is None:
+            if self.__logprob is None:
+                return None
+            self.__prob = 2 ** (self.__logprob)
+        return self.__prob
+
+    def logprob(self):
+        """
+        Return ``log(p)``, where ``p`` is the probability associated
+        with this object.
+
+        :rtype: float
+        """
+        if self.__logprob is None:
+            if self.__prob is None:
+                return None
+            self.__logprob = math.log(self.__prob, 2)
+        return self.__logprob
+
+
+class ImmutableProbabilisticMixIn(ProbabilisticMixIn):
+    def set_prob(self, prob):
+        raise ValueError("%s is immutable" % self.__class__.__name__)
+
+    def set_logprob(self, prob):
+        raise ValueError("%s is immutable" % self.__class__.__name__)
+
+
+## Helper function for processing keyword arguments
+
+
+def _get_kwarg(kwargs, key, default):
+    if key in kwargs:
+        arg = kwargs[key]
+        del kwargs[key]
+    else:
+        arg = default
+    return arg
+
+
+##//////////////////////////////////////////////////////
+##  Demonstration
+##//////////////////////////////////////////////////////
+
+
+def _create_rand_fdist(numsamples, numoutcomes):
+    """
+    Create a new frequency distribution, with random samples.  The
+    samples are numbers from 1 to ``numsamples``, and are generated by
+    summing two numbers, each of which has a uniform distribution.
+    """
+
+    fdist = FreqDist()
+    for x in range(numoutcomes):
+        y = random.randint(1, (1 + numsamples) // 2) + random.randint(
+            0, numsamples // 2
+        )
+        fdist[y] += 1
+    return fdist
+
+
+def _create_sum_pdist(numsamples):
+    """
+    Return the true probability distribution for the experiment
+    ``_create_rand_fdist(numsamples, x)``.
+    """
+    fdist = FreqDist()
+    for x in range(1, (1 + numsamples) // 2 + 1):
+        for y in range(0, numsamples // 2 + 1):
+            fdist[x + y] += 1
+    return MLEProbDist(fdist)
+
+
+def demo(numsamples=6, numoutcomes=500):
+    """
+    A demonstration of frequency distributions and probability
+    distributions.  This demonstration creates three frequency
+    distributions with, and uses them to sample a random process with
+    ``numsamples`` samples.  Each frequency distribution is sampled
+    ``numoutcomes`` times.  These three frequency distributions are
+    then used to build six probability distributions.  Finally, the
+    probability estimates of these distributions are compared to the
+    actual probability of each sample.
+
+    :type numsamples: int
+    :param numsamples: The number of samples to use in each demo
+        frequency distributions.
+    :type numoutcomes: int
+    :param numoutcomes: The total number of outcomes for each
+        demo frequency distribution.  These outcomes are divided into
+        ``numsamples`` bins.
+    :rtype: None
+    """
+
+    # Randomly sample a stochastic process three times.
+    fdist1 = _create_rand_fdist(numsamples, numoutcomes)
+    fdist2 = _create_rand_fdist(numsamples, numoutcomes)
+    fdist3 = _create_rand_fdist(numsamples, numoutcomes)
+
+    # Use our samples to create probability distributions.
+    pdists = [
+        MLEProbDist(fdist1),
+        LidstoneProbDist(fdist1, 0.5, numsamples),
+        HeldoutProbDist(fdist1, fdist2, numsamples),
+        HeldoutProbDist(fdist2, fdist1, numsamples),
+        CrossValidationProbDist([fdist1, fdist2, fdist3], numsamples),
+        SimpleGoodTuringProbDist(fdist1),
+        SimpleGoodTuringProbDist(fdist1, 7),
+        _create_sum_pdist(numsamples),
+    ]
+
+    # Find the probability of each sample.
+    vals = []
+    for n in range(1, numsamples + 1):
+        vals.append(tuple([n, fdist1.freq(n)] + [pdist.prob(n) for pdist in pdists]))
+
+    # Print the results in a formatted table.
+    print(
+        "%d samples (1-%d); %d outcomes were sampled for each FreqDist"
+        % (numsamples, numsamples, numoutcomes)
+    )
+    print("=" * 9 * (len(pdists) + 2))
+    FORMATSTR = "      FreqDist " + "%8s " * (len(pdists) - 1) + "|  Actual"
+    print(FORMATSTR % tuple(repr(pdist)[1:9] for pdist in pdists[:-1]))
+    print("-" * 9 * (len(pdists) + 2))
+    FORMATSTR = "%3d   %8.6f " + "%8.6f " * (len(pdists) - 1) + "| %8.6f"
+    for val in vals:
+        print(FORMATSTR % val)
+
+    # Print the totals for each column (should all be 1.0)
+    zvals = list(zip(*vals))
+    sums = [sum(val) for val in zvals[1:]]
+    print("-" * 9 * (len(pdists) + 2))
+    FORMATSTR = "Total " + "%8.6f " * (len(pdists)) + "| %8.6f"
+    print(FORMATSTR % tuple(sums))
+    print("=" * 9 * (len(pdists) + 2))
+
+    # Display the distributions themselves, if they're short enough.
+    if len("%s" % fdist1) < 70:
+        print("  fdist1: %s" % fdist1)
+        print("  fdist2: %s" % fdist2)
+        print("  fdist3: %s" % fdist3)
+    print()
+
+    print("Generating:")
+    for pdist in pdists:
+        fdist = FreqDist(pdist.generate() for i in range(5000))
+        print("{:>20} {}".format(pdist.__class__.__name__[:20], ("%s" % fdist)[:55]))
+    print()
+
+
+def gt_demo():
+    from nltk import corpus
+
+    emma_words = corpus.gutenberg.words("austen-emma.txt")
+    fd = FreqDist(emma_words)
+    sgt = SimpleGoodTuringProbDist(fd)
+    print("{:>18} {:>8}  {:>14}".format("word", "frequency", "SimpleGoodTuring"))
+    fd_keys_sorted = (
+        key for key, value in sorted(fd.items(), key=lambda item: item[1], reverse=True)
+    )
+    for key in fd_keys_sorted:
+        print("%18s %8d  %14e" % (key, fd[key], sgt.prob(key)))
+
+
+if __name__ == "__main__":
+    demo(6, 10)
+    demo(5, 5000)
+    gt_demo()
+
+__all__ = [
+    "ConditionalFreqDist",
+    "ConditionalProbDist",
+    "ConditionalProbDistI",
+    "CrossValidationProbDist",
+    "DictionaryConditionalProbDist",
+    "DictionaryProbDist",
+    "ELEProbDist",
+    "FreqDist",
+    "SimpleGoodTuringProbDist",
+    "HeldoutProbDist",
+    "ImmutableProbabilisticMixIn",
+    "LaplaceProbDist",
+    "LidstoneProbDist",
+    "MLEProbDist",
+    "MutableProbDist",
+    "KneserNeyProbDist",
+    "ProbDistI",
+    "ProbabilisticMixIn",
+    "UniformProbDist",
+    "WittenBellProbDist",
+    "add_logs",
+    "log_likelihood",
+    "sum_logs",
+    "entropy",
+]

llmeval-env/lib/python3.10/site-packages/nltk/stem/api.py

@@ -0,0 +1,27 @@
+# Natural Language Toolkit: Stemmer Interface
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Trevor Cohn <[email protected]>
+#         Edward Loper <[email protected]>
+#         Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from abc import ABCMeta, abstractmethod
+
+
+class StemmerI(metaclass=ABCMeta):
+    """
+    A processing interface for removing morphological affixes from
+    words.  This process is known as stemming.
+
+    """
+
+    @abstractmethod
+    def stem(self, token):
+        """
+        Strip affixes from the token and return the stem.
+
+        :param token: The token that should be stemmed.
+        :type token: str
+        """

llmeval-env/lib/python3.10/site-packages/nltk/stem/util.py

@@ -0,0 +1,25 @@
+# Natural Language Toolkit: Stemmer Utilities
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Helder <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+
+def suffix_replace(original, old, new):
+    """
+    Replaces the old suffix of the original string by a new suffix
+    """
+    return original[: -len(old)] + new
+
+
+def prefix_replace(original, old, new):
+    """
+    Replaces the old prefix of the original string by a new suffix
+
+    :param original: string
+    :param old: string
+    :param new: string
+    :return: string
+    """
+    return new + original[len(old) :]

llmeval-env/lib/python3.10/site-packages/nltk/text.py

@@ -0,0 +1,779 @@
+# Natural Language Toolkit: Texts
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+#         Edward Loper <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+This module brings together a variety of NLTK functionality for
+text analysis, and provides simple, interactive interfaces.
+Functionality includes: concordancing, collocation discovery,
+regular expression search over tokenized strings, and
+distributional similarity.
+"""
+
+import re
+import sys
+from collections import Counter, defaultdict, namedtuple
+from functools import reduce
+from math import log
+
+from nltk.collocations import BigramCollocationFinder
+from nltk.lm import MLE
+from nltk.lm.preprocessing import padded_everygram_pipeline
+from nltk.metrics import BigramAssocMeasures, f_measure
+from nltk.probability import ConditionalFreqDist as CFD
+from nltk.probability import FreqDist
+from nltk.tokenize import sent_tokenize
+from nltk.util import LazyConcatenation, tokenwrap
+
+ConcordanceLine = namedtuple(
+    "ConcordanceLine",
+    ["left", "query", "right", "offset", "left_print", "right_print", "line"],
+)
+
+
+class ContextIndex:
+    """
+    A bidirectional index between words and their 'contexts' in a text.
+    The context of a word is usually defined to be the words that occur
+    in a fixed window around the word; but other definitions may also
+    be used by providing a custom context function.
+    """
+
+    @staticmethod
+    def _default_context(tokens, i):
+        """One left token and one right token, normalized to lowercase"""
+        left = tokens[i - 1].lower() if i != 0 else "*START*"
+        right = tokens[i + 1].lower() if i != len(tokens) - 1 else "*END*"
+        return (left, right)
+
+    def __init__(self, tokens, context_func=None, filter=None, key=lambda x: x):
+        self._key = key
+        self._tokens = tokens
+        if context_func:
+            self._context_func = context_func
+        else:
+            self._context_func = self._default_context
+        if filter:
+            tokens = [t for t in tokens if filter(t)]
+        self._word_to_contexts = CFD(
+            (self._key(w), self._context_func(tokens, i)) for i, w in enumerate(tokens)
+        )
+        self._context_to_words = CFD(
+            (self._context_func(tokens, i), self._key(w)) for i, w in enumerate(tokens)
+        )
+
+    def tokens(self):
+        """
+        :rtype: list(str)
+        :return: The document that this context index was
+            created from.
+        """
+        return self._tokens
+
+    def word_similarity_dict(self, word):
+        """
+        Return a dictionary mapping from words to 'similarity scores,'
+        indicating how often these two words occur in the same
+        context.
+        """
+        word = self._key(word)
+        word_contexts = set(self._word_to_contexts[word])
+
+        scores = {}
+        for w, w_contexts in self._word_to_contexts.items():
+            scores[w] = f_measure(word_contexts, set(w_contexts))
+
+        return scores
+
+    def similar_words(self, word, n=20):
+        scores = defaultdict(int)
+        for c in self._word_to_contexts[self._key(word)]:
+            for w in self._context_to_words[c]:
+                if w != word:
+                    scores[w] += (
+                        self._context_to_words[c][word] * self._context_to_words[c][w]
+                    )
+        return sorted(scores, key=scores.get, reverse=True)[:n]
+
+    def common_contexts(self, words, fail_on_unknown=False):
+        """
+        Find contexts where the specified words can all appear; and
+        return a frequency distribution mapping each context to the
+        number of times that context was used.
+
+        :param words: The words used to seed the similarity search
+        :type words: str
+        :param fail_on_unknown: If true, then raise a value error if
+            any of the given words do not occur at all in the index.
+        """
+        words = [self._key(w) for w in words]
+        contexts = [set(self._word_to_contexts[w]) for w in words]
+        empty = [words[i] for i in range(len(words)) if not contexts[i]]
+        common = reduce(set.intersection, contexts)
+        if empty and fail_on_unknown:
+            raise ValueError("The following word(s) were not found:", " ".join(words))
+        elif not common:
+            # nothing in common -- just return an empty freqdist.
+            return FreqDist()
+        else:
+            fd = FreqDist(
+                c for w in words for c in self._word_to_contexts[w] if c in common
+            )
+            return fd
+
+
+class ConcordanceIndex:
+    """
+    An index that can be used to look up the offset locations at which
+    a given word occurs in a document.
+    """
+
+    def __init__(self, tokens, key=lambda x: x):
+        """
+        Construct a new concordance index.
+
+        :param tokens: The document (list of tokens) that this
+            concordance index was created from.  This list can be used
+            to access the context of a given word occurrence.
+        :param key: A function that maps each token to a normalized
+            version that will be used as a key in the index.  E.g., if
+            you use ``key=lambda s:s.lower()``, then the index will be
+            case-insensitive.
+        """
+        self._tokens = tokens
+        """The document (list of tokens) that this concordance index
+           was created from."""
+
+        self._key = key
+        """Function mapping each token to an index key (or None)."""
+
+        self._offsets = defaultdict(list)
+        """Dictionary mapping words (or keys) to lists of offset indices."""
+        # Initialize the index (self._offsets)
+        for index, word in enumerate(tokens):
+            word = self._key(word)
+            self._offsets[word].append(index)
+
+    def tokens(self):
+        """
+        :rtype: list(str)
+        :return: The document that this concordance index was
+            created from.
+        """
+        return self._tokens
+
+    def offsets(self, word):
+        """
+        :rtype: list(int)
+        :return: A list of the offset positions at which the given
+            word occurs.  If a key function was specified for the
+            index, then given word's key will be looked up.
+        """
+        word = self._key(word)
+        return self._offsets[word]
+
+    def __repr__(self):
+        return "<ConcordanceIndex for %d tokens (%d types)>" % (
+            len(self._tokens),
+            len(self._offsets),
+        )
+
+    def find_concordance(self, word, width=80):
+        """
+        Find all concordance lines given the query word.
+
+        Provided with a list of words, these will be found as a phrase.
+        """
+        if isinstance(word, list):
+            phrase = word
+        else:
+            phrase = [word]
+
+        half_width = (width - len(" ".join(phrase)) - 2) // 2
+        context = width // 4  # approx number of words of context
+
+        # Find the instances of the word to create the ConcordanceLine
+        concordance_list = []
+        offsets = self.offsets(phrase[0])
+        for i, word in enumerate(phrase[1:]):
+            word_offsets = {offset - i - 1 for offset in self.offsets(word)}
+            offsets = sorted(word_offsets.intersection(offsets))
+        if offsets:
+            for i in offsets:
+                query_word = " ".join(self._tokens[i : i + len(phrase)])
+                # Find the context of query word.
+                left_context = self._tokens[max(0, i - context) : i]
+                right_context = self._tokens[i + len(phrase) : i + context]
+                # Create the pretty lines with the query_word in the middle.
+                left_print = " ".join(left_context)[-half_width:]
+                right_print = " ".join(right_context)[:half_width]
+                # The WYSIWYG line of the concordance.
+                line_print = " ".join([left_print, query_word, right_print])
+                # Create the ConcordanceLine
+                concordance_line = ConcordanceLine(
+                    left_context,
+                    query_word,
+                    right_context,
+                    i,
+                    left_print,
+                    right_print,
+                    line_print,
+                )
+                concordance_list.append(concordance_line)
+        return concordance_list
+
+    def print_concordance(self, word, width=80, lines=25):
+        """
+        Print concordance lines given the query word.
+        :param word: The target word or phrase (a list of strings)
+        :type word: str or list
+        :param lines: The number of lines to display (default=25)
+        :type lines: int
+        :param width: The width of each line, in characters (default=80)
+        :type width: int
+        :param save: The option to save the concordance.
+        :type save: bool
+        """
+        concordance_list = self.find_concordance(word, width=width)
+
+        if not concordance_list:
+            print("no matches")
+        else:
+            lines = min(lines, len(concordance_list))
+            print(f"Displaying {lines} of {len(concordance_list)} matches:")
+            for i, concordance_line in enumerate(concordance_list[:lines]):
+                print(concordance_line.line)
+
+
+class TokenSearcher:
+    """
+    A class that makes it easier to use regular expressions to search
+    over tokenized strings.  The tokenized string is converted to a
+    string where tokens are marked with angle brackets -- e.g.,
+    ``'<the><window><is><still><open>'``.  The regular expression
+    passed to the ``findall()`` method is modified to treat angle
+    brackets as non-capturing parentheses, in addition to matching the
+    token boundaries; and to have ``'.'`` not match the angle brackets.
+    """
+
+    def __init__(self, tokens):
+        self._raw = "".join("<" + w + ">" for w in tokens)
+
+    def findall(self, regexp):
+        """
+        Find instances of the regular expression in the text.
+        The text is a list of tokens, and a regexp pattern to match
+        a single token must be surrounded by angle brackets.  E.g.
+
+        >>> from nltk.text import TokenSearcher
+        >>> from nltk.book import text1, text5, text9
+        >>> text5.findall("<.*><.*><bro>")
+        you rule bro; telling you bro; u twizted bro
+        >>> text1.findall("<a>(<.*>)<man>")
+        monied; nervous; dangerous; white; white; white; pious; queer; good;
+        mature; white; Cape; great; wise; wise; butterless; white; fiendish;
+        pale; furious; better; certain; complete; dismasted; younger; brave;
+        brave; brave; brave
+        >>> text9.findall("<th.*>{3,}")
+        thread through those; the thought that; that the thing; the thing
+        that; that that thing; through these than through; them that the;
+        through the thick; them that they; thought that the
+
+        :param regexp: A regular expression
+        :type regexp: str
+        """
+        # preprocess the regular expression
+        regexp = re.sub(r"\s", "", regexp)
+        regexp = re.sub(r"<", "(?:<(?:", regexp)
+        regexp = re.sub(r">", ")>)", regexp)
+        regexp = re.sub(r"(?<!\\)\.", "[^>]", regexp)
+
+        # perform the search
+        hits = re.findall(regexp, self._raw)
+
+        # Sanity check
+        for h in hits:
+            if not h.startswith("<") and h.endswith(">"):
+                raise ValueError("Bad regexp for TokenSearcher.findall")
+
+        # postprocess the output
+        hits = [h[1:-1].split("><") for h in hits]
+        return hits
+
+
+class Text:
+    """
+    A wrapper around a sequence of simple (string) tokens, which is
+    intended to support initial exploration of texts (via the
+    interactive console).  Its methods perform a variety of analyses
+    on the text's contexts (e.g., counting, concordancing, collocation
+    discovery), and display the results.  If you wish to write a
+    program which makes use of these analyses, then you should bypass
+    the ``Text`` class, and use the appropriate analysis function or
+    class directly instead.
+
+    A ``Text`` is typically initialized from a given document or
+    corpus.  E.g.:
+
+    >>> import nltk.corpus
+    >>> from nltk.text import Text
+    >>> moby = Text(nltk.corpus.gutenberg.words('melville-moby_dick.txt'))
+
+    """
+
+    # This defeats lazy loading, but makes things faster.  This
+    # *shouldn't* be necessary because the corpus view *should* be
+    # doing intelligent caching, but without this it's running slow.
+    # Look into whether the caching is working correctly.
+    _COPY_TOKENS = True
+
+    def __init__(self, tokens, name=None):
+        """
+        Create a Text object.
+
+        :param tokens: The source text.
+        :type tokens: sequence of str
+        """
+        if self._COPY_TOKENS:
+            tokens = list(tokens)
+        self.tokens = tokens
+
+        if name:
+            self.name = name
+        elif "]" in tokens[:20]:
+            end = tokens[:20].index("]")
+            self.name = " ".join(str(tok) for tok in tokens[1:end])
+        else:
+            self.name = " ".join(str(tok) for tok in tokens[:8]) + "..."
+
+    # ////////////////////////////////////////////////////////////
+    # Support item & slice access
+    # ////////////////////////////////////////////////////////////
+
+    def __getitem__(self, i):
+        return self.tokens[i]
+
+    def __len__(self):
+        return len(self.tokens)
+
+    # ////////////////////////////////////////////////////////////
+    # Interactive console methods
+    # ////////////////////////////////////////////////////////////
+
+    def concordance(self, word, width=79, lines=25):
+        """
+        Prints a concordance for ``word`` with the specified context window.
+        Word matching is not case-sensitive.
+
+        :param word: The target word or phrase (a list of strings)
+        :type word: str or list
+        :param width: The width of each line, in characters (default=80)
+        :type width: int
+        :param lines: The number of lines to display (default=25)
+        :type lines: int
+
+        :seealso: ``ConcordanceIndex``
+        """
+        if "_concordance_index" not in self.__dict__:
+            self._concordance_index = ConcordanceIndex(
+                self.tokens, key=lambda s: s.lower()
+            )
+
+        return self._concordance_index.print_concordance(word, width, lines)
+
+    def concordance_list(self, word, width=79, lines=25):
+        """
+        Generate a concordance for ``word`` with the specified context window.
+        Word matching is not case-sensitive.
+
+        :param word: The target word or phrase (a list of strings)
+        :type word: str or list
+        :param width: The width of each line, in characters (default=80)
+        :type width: int
+        :param lines: The number of lines to display (default=25)
+        :type lines: int
+
+        :seealso: ``ConcordanceIndex``
+        """
+        if "_concordance_index" not in self.__dict__:
+            self._concordance_index = ConcordanceIndex(
+                self.tokens, key=lambda s: s.lower()
+            )
+        return self._concordance_index.find_concordance(word, width)[:lines]
+
+    def collocation_list(self, num=20, window_size=2):
+        """
+        Return collocations derived from the text, ignoring stopwords.
+
+            >>> from nltk.book import text4
+            >>> text4.collocation_list()[:2]
+            [('United', 'States'), ('fellow', 'citizens')]
+
+        :param num: The maximum number of collocations to return.
+        :type num: int
+        :param window_size: The number of tokens spanned by a collocation (default=2)
+        :type window_size: int
+        :rtype: list(tuple(str, str))
+        """
+        if not (
+            "_collocations" in self.__dict__
+            and self._num == num
+            and self._window_size == window_size
+        ):
+            self._num = num
+            self._window_size = window_size
+
+            # print("Building collocations list")
+            from nltk.corpus import stopwords
+
+            ignored_words = stopwords.words("english")
+            finder = BigramCollocationFinder.from_words(self.tokens, window_size)
+            finder.apply_freq_filter(2)
+            finder.apply_word_filter(lambda w: len(w) < 3 or w.lower() in ignored_words)
+            bigram_measures = BigramAssocMeasures()
+            self._collocations = list(
+                finder.nbest(bigram_measures.likelihood_ratio, num)
+            )
+        return self._collocations
+
+    def collocations(self, num=20, window_size=2):
+        """
+        Print collocations derived from the text, ignoring stopwords.
+
+            >>> from nltk.book import text4
+            >>> text4.collocations() # doctest: +NORMALIZE_WHITESPACE
+            United States; fellow citizens; years ago; four years; Federal
+            Government; General Government; American people; Vice President; God
+            bless; Chief Justice; one another; fellow Americans; Old World;
+            Almighty God; Fellow citizens; Chief Magistrate; every citizen; Indian
+            tribes; public debt; foreign nations
+
+
+        :param num: The maximum number of collocations to print.
+        :type num: int
+        :param window_size: The number of tokens spanned by a collocation (default=2)
+        :type window_size: int
+        """
+
+        collocation_strings = [
+            w1 + " " + w2 for w1, w2 in self.collocation_list(num, window_size)
+        ]
+        print(tokenwrap(collocation_strings, separator="; "))
+
+    def count(self, word):
+        """
+        Count the number of times this word appears in the text.
+        """
+        return self.tokens.count(word)
+
+    def index(self, word):
+        """
+        Find the index of the first occurrence of the word in the text.
+        """
+        return self.tokens.index(word)
+
+    def readability(self, method):
+        # code from nltk_contrib.readability
+        raise NotImplementedError
+
+    def similar(self, word, num=20):
+        """
+        Distributional similarity: find other words which appear in the
+        same contexts as the specified word; list most similar words first.
+
+        :param word: The word used to seed the similarity search
+        :type word: str
+        :param num: The number of words to generate (default=20)
+        :type num: int
+        :seealso: ContextIndex.similar_words()
+        """
+        if "_word_context_index" not in self.__dict__:
+            # print('Building word-context index...')
+            self._word_context_index = ContextIndex(
+                self.tokens, filter=lambda x: x.isalpha(), key=lambda s: s.lower()
+            )
+
+        # words = self._word_context_index.similar_words(word, num)
+
+        word = word.lower()
+        wci = self._word_context_index._word_to_contexts
+        if word in wci.conditions():
+            contexts = set(wci[word])
+            fd = Counter(
+                w
+                for w in wci.conditions()
+                for c in wci[w]
+                if c in contexts and not w == word
+            )
+            words = [w for w, _ in fd.most_common(num)]
+            print(tokenwrap(words))
+        else:
+            print("No matches")
+
+    def common_contexts(self, words, num=20):
+        """
+        Find contexts where the specified words appear; list
+        most frequent common contexts first.
+
+        :param words: The words used to seed the similarity search
+        :type words: str
+        :param num: The number of words to generate (default=20)
+        :type num: int
+        :seealso: ContextIndex.common_contexts()
+        """
+        if "_word_context_index" not in self.__dict__:
+            # print('Building word-context index...')
+            self._word_context_index = ContextIndex(
+                self.tokens, key=lambda s: s.lower()
+            )
+
+        try:
+            fd = self._word_context_index.common_contexts(words, True)
+            if not fd:
+                print("No common contexts were found")
+            else:
+                ranked_contexts = [w for w, _ in fd.most_common(num)]
+                print(tokenwrap(w1 + "_" + w2 for w1, w2 in ranked_contexts))
+
+        except ValueError as e:
+            print(e)
+
+    def dispersion_plot(self, words):
+        """
+        Produce a plot showing the distribution of the words through the text.
+        Requires pylab to be installed.
+
+        :param words: The words to be plotted
+        :type words: list(str)
+        :seealso: nltk.draw.dispersion_plot()
+        """
+        from nltk.draw import dispersion_plot
+
+        dispersion_plot(self, words)
+
+    def _train_default_ngram_lm(self, tokenized_sents, n=3):
+        train_data, padded_sents = padded_everygram_pipeline(n, tokenized_sents)
+        model = MLE(order=n)
+        model.fit(train_data, padded_sents)
+        return model
+
+    def generate(self, length=100, text_seed=None, random_seed=42):
+        """
+        Print random text, generated using a trigram language model.
+        See also `help(nltk.lm)`.
+
+        :param length: The length of text to generate (default=100)
+        :type length: int
+
+        :param text_seed: Generation can be conditioned on preceding context.
+        :type text_seed: list(str)
+
+        :param random_seed: A random seed or an instance of `random.Random`. If provided,
+            makes the random sampling part of generation reproducible. (default=42)
+        :type random_seed: int
+        """
+        # Create the model when using it the first time.
+        self._tokenized_sents = [
+            sent.split(" ") for sent in sent_tokenize(" ".join(self.tokens))
+        ]
+        if not hasattr(self, "_trigram_model"):
+            print("Building ngram index...", file=sys.stderr)
+            self._trigram_model = self._train_default_ngram_lm(
+                self._tokenized_sents, n=3
+            )
+
+        generated_tokens = []
+
+        assert length > 0, "The `length` must be more than 0."
+        while len(generated_tokens) < length:
+            for idx, token in enumerate(
+                self._trigram_model.generate(
+                    length, text_seed=text_seed, random_seed=random_seed
+                )
+            ):
+                if token == "<s>":
+                    continue
+                if token == "</s>":
+                    break
+                generated_tokens.append(token)
+            random_seed += 1
+
+        prefix = " ".join(text_seed) + " " if text_seed else ""
+        output_str = prefix + tokenwrap(generated_tokens[:length])
+        print(output_str)
+        return output_str
+
+    def plot(self, *args):
+        """
+        See documentation for FreqDist.plot()
+        :seealso: nltk.prob.FreqDist.plot()
+        """
+        return self.vocab().plot(*args)
+
+    def vocab(self):
+        """
+        :seealso: nltk.prob.FreqDist
+        """
+        if "_vocab" not in self.__dict__:
+            # print("Building vocabulary index...")
+            self._vocab = FreqDist(self)
+        return self._vocab
+
+    def findall(self, regexp):
+        """
+        Find instances of the regular expression in the text.
+        The text is a list of tokens, and a regexp pattern to match
+        a single token must be surrounded by angle brackets.  E.g.
+
+        >>> from nltk.book import text1, text5, text9
+        >>> text5.findall("<.*><.*><bro>")
+        you rule bro; telling you bro; u twizted bro
+        >>> text1.findall("<a>(<.*>)<man>")
+        monied; nervous; dangerous; white; white; white; pious; queer; good;
+        mature; white; Cape; great; wise; wise; butterless; white; fiendish;
+        pale; furious; better; certain; complete; dismasted; younger; brave;
+        brave; brave; brave
+        >>> text9.findall("<th.*>{3,}")
+        thread through those; the thought that; that the thing; the thing
+        that; that that thing; through these than through; them that the;
+        through the thick; them that they; thought that the
+
+        :param regexp: A regular expression
+        :type regexp: str
+        """
+
+        if "_token_searcher" not in self.__dict__:
+            self._token_searcher = TokenSearcher(self)
+
+        hits = self._token_searcher.findall(regexp)
+        hits = [" ".join(h) for h in hits]
+        print(tokenwrap(hits, "; "))
+
+    # ////////////////////////////////////////////////////////////
+    # Helper Methods
+    # ////////////////////////////////////////////////////////////
+
+    _CONTEXT_RE = re.compile(r"\w+|[\.\!\?]")
+
+    def _context(self, tokens, i):
+        """
+        One left & one right token, both case-normalized.  Skip over
+        non-sentence-final punctuation.  Used by the ``ContextIndex``
+        that is created for ``similar()`` and ``common_contexts()``.
+        """
+        # Left context
+        j = i - 1
+        while j >= 0 and not self._CONTEXT_RE.match(tokens[j]):
+            j -= 1
+        left = tokens[j] if j != 0 else "*START*"
+
+        # Right context
+        j = i + 1
+        while j < len(tokens) and not self._CONTEXT_RE.match(tokens[j]):
+            j += 1
+        right = tokens[j] if j != len(tokens) else "*END*"
+
+        return (left, right)
+
+    # ////////////////////////////////////////////////////////////
+    # String Display
+    # ////////////////////////////////////////////////////////////
+
+    def __str__(self):
+        return "<Text: %s>" % self.name
+
+    def __repr__(self):
+        return "<Text: %s>" % self.name
+
+
+# Prototype only; this approach will be slow to load
+class TextCollection(Text):
+    """A collection of texts, which can be loaded with list of texts, or
+    with a corpus consisting of one or more texts, and which supports
+    counting, concordancing, collocation discovery, etc.  Initialize a
+    TextCollection as follows:
+
+    >>> import nltk.corpus
+    >>> from nltk.text import TextCollection
+    >>> from nltk.book import text1, text2, text3
+    >>> gutenberg = TextCollection(nltk.corpus.gutenberg)
+    >>> mytexts = TextCollection([text1, text2, text3])
+
+    Iterating over a TextCollection produces all the tokens of all the
+    texts in order.
+    """
+
+    def __init__(self, source):
+        if hasattr(source, "words"):  # bridge to the text corpus reader
+            source = [source.words(f) for f in source.fileids()]
+
+        self._texts = source
+        Text.__init__(self, LazyConcatenation(source))
+        self._idf_cache = {}
+
+    def tf(self, term, text):
+        """The frequency of the term in text."""
+        return text.count(term) / len(text)
+
+    def idf(self, term):
+        """The number of texts in the corpus divided by the
+        number of texts that the term appears in.
+        If a term does not appear in the corpus, 0.0 is returned."""
+        # idf values are cached for performance.
+        idf = self._idf_cache.get(term)
+        if idf is None:
+            matches = len([True for text in self._texts if term in text])
+            if len(self._texts) == 0:
+                raise ValueError("IDF undefined for empty document collection")
+            idf = log(len(self._texts) / matches) if matches else 0.0
+            self._idf_cache[term] = idf
+        return idf
+
+    def tf_idf(self, term, text):
+        return self.tf(term, text) * self.idf(term)
+
+
+def demo():
+    from nltk.corpus import brown
+
+    text = Text(brown.words(categories="news"))
+    print(text)
+    print()
+    print("Concordance:")
+    text.concordance("news")
+    print()
+    print("Distributionally similar words:")
+    text.similar("news")
+    print()
+    print("Collocations:")
+    text.collocations()
+    print()
+    # print("Automatically generated text:")
+    # text.generate()
+    # print()
+    print("Dispersion plot:")
+    text.dispersion_plot(["news", "report", "said", "announced"])
+    print()
+    print("Vocabulary plot:")
+    text.plot(50)
+    print()
+    print("Indexing:")
+    print("text[3]:", text[3])
+    print("text[3:5]:", text[3:5])
+    print("text.vocab()['news']:", text.vocab()["news"])
+
+
+if __name__ == "__main__":
+    demo()
+
+__all__ = [
+    "ContextIndex",
+    "ConcordanceIndex",
+    "TokenSearcher",
+    "Text",
+    "TextCollection",
+]

llmeval-env/lib/python3.10/site-packages/nltk/tgrep.py

@@ -0,0 +1,1039 @@
+#!/usr/bin/env python
+#
+# Natural Language Toolkit: TGrep search
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Will Roberts <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+============================================
+ TGrep search implementation for NLTK trees
+============================================
+
+This module supports TGrep2 syntax for matching parts of NLTK Trees.
+Note that many tgrep operators require the tree passed to be a
+``ParentedTree``.
+
+External links:
+
+- `Tgrep tutorial <https://www.stanford.edu/dept/linguistics/corpora/cas-tut-tgrep.html>`_
+- `Tgrep2 manual <http://tedlab.mit.edu/~dr/Tgrep2/tgrep2.pdf>`_
+- `Tgrep2 source <http://tedlab.mit.edu/~dr/Tgrep2/>`_
+
+Usage
+=====
+
+>>> from nltk.tree import ParentedTree
+>>> from nltk.tgrep import tgrep_nodes, tgrep_positions
+>>> tree = ParentedTree.fromstring('(S (NP (DT the) (JJ big) (NN dog)) (VP bit) (NP (DT a) (NN cat)))')
+>>> list(tgrep_nodes('NN', [tree]))
+[[ParentedTree('NN', ['dog']), ParentedTree('NN', ['cat'])]]
+>>> list(tgrep_positions('NN', [tree]))
+[[(0, 2), (2, 1)]]
+>>> list(tgrep_nodes('DT', [tree]))
+[[ParentedTree('DT', ['the']), ParentedTree('DT', ['a'])]]
+>>> list(tgrep_nodes('DT $ JJ', [tree]))
+[[ParentedTree('DT', ['the'])]]
+
+This implementation adds syntax to select nodes based on their NLTK
+tree position.  This syntax is ``N`` plus a Python tuple representing
+the tree position.  For instance, ``N()``, ``N(0,)``, ``N(0,0)`` are
+valid node selectors.  Example:
+
+>>> tree = ParentedTree.fromstring('(S (NP (DT the) (JJ big) (NN dog)) (VP bit) (NP (DT a) (NN cat)))')
+>>> tree[0,0]
+ParentedTree('DT', ['the'])
+>>> tree[0,0].treeposition()
+(0, 0)
+>>> list(tgrep_nodes('N(0,0)', [tree]))
+[[ParentedTree('DT', ['the'])]]
+
+Caveats:
+========
+
+- Link modifiers: "?" and "=" are not implemented.
+- Tgrep compatibility: Using "@" for "!", "{" for "<", "}" for ">" are
+  not implemented.
+- The "=" and "~" links are not implemented.
+
+Known Issues:
+=============
+
+- There are some issues with link relations involving leaf nodes
+  (which are represented as bare strings in NLTK trees).  For
+  instance, consider the tree::
+
+      (S (A x))
+
+  The search string ``* !>> S`` should select all nodes which are not
+  dominated in some way by an ``S`` node (i.e., all nodes which are
+  not descendants of an ``S``).  Clearly, in this tree, the only node
+  which fulfills this criterion is the top node (since it is not
+  dominated by anything).  However, the code here will find both the
+  top node and the leaf node ``x``.  This is because we cannot recover
+  the parent of the leaf, since it is stored as a bare string.
+
+  A possible workaround, when performing this kind of search, would be
+  to filter out all leaf nodes.
+
+Implementation notes
+====================
+
+This implementation is (somewhat awkwardly) based on lambda functions
+which are predicates on a node.  A predicate is a function which is
+either True or False; using a predicate function, we can identify sets
+of nodes with particular properties.  A predicate function, could, for
+instance, return True only if a particular node has a label matching a
+particular regular expression, and has a daughter node which has no
+sisters.  Because tgrep2 search strings can do things statefully (such
+as substituting in macros, and binding nodes with node labels), the
+actual predicate function is declared with three arguments::
+
+    pred = lambda n, m, l: return True # some logic here
+
+``n``
+    is a node in a tree; this argument must always be given
+
+``m``
+    contains a dictionary, mapping macro names onto predicate functions
+
+``l``
+    is a dictionary to map node labels onto nodes in the tree
+
+``m`` and ``l`` are declared to default to ``None``, and so need not be
+specified in a call to a predicate.  Predicates which call other
+predicates must always pass the value of these arguments on.  The
+top-level predicate (constructed by ``_tgrep_exprs_action``) binds the
+macro definitions to ``m`` and initialises ``l`` to an empty dictionary.
+"""
+
+import functools
+import re
+
+try:
+    import pyparsing
+except ImportError:
+    print("Warning: nltk.tgrep will not work without the `pyparsing` package")
+    print("installed.")
+
+import nltk.tree
+
+
+class TgrepException(Exception):
+    """Tgrep exception type."""
+
+    pass
+
+
+def ancestors(node):
+    """
+    Returns the list of all nodes dominating the given tree node.
+    This method will not work with leaf nodes, since there is no way
+    to recover the parent.
+    """
+    results = []
+    try:
+        current = node.parent()
+    except AttributeError:
+        # if node is a leaf, we cannot retrieve its parent
+        return results
+    while current:
+        results.append(current)
+        current = current.parent()
+    return results
+
+
+def unique_ancestors(node):
+    """
+    Returns the list of all nodes dominating the given node, where
+    there is only a single path of descent.
+    """
+    results = []
+    try:
+        current = node.parent()
+    except AttributeError:
+        # if node is a leaf, we cannot retrieve its parent
+        return results
+    while current and len(current) == 1:
+        results.append(current)
+        current = current.parent()
+    return results
+
+
+def _descendants(node):
+    """
+    Returns the list of all nodes which are descended from the given
+    tree node in some way.
+    """
+    try:
+        treepos = node.treepositions()
+    except AttributeError:
+        return []
+    return [node[x] for x in treepos[1:]]
+
+
+def _leftmost_descendants(node):
+    """
+    Returns the set of all nodes descended in some way through
+    left branches from this node.
+    """
+    try:
+        treepos = node.treepositions()
+    except AttributeError:
+        return []
+    return [node[x] for x in treepos[1:] if all(y == 0 for y in x)]
+
+
+def _rightmost_descendants(node):
+    """
+    Returns the set of all nodes descended in some way through
+    right branches from this node.
+    """
+    try:
+        rightmost_leaf = max(node.treepositions())
+    except AttributeError:
+        return []
+    return [node[rightmost_leaf[:i]] for i in range(1, len(rightmost_leaf) + 1)]
+
+
+def _istree(obj):
+    """Predicate to check whether `obj` is a nltk.tree.Tree."""
+    return isinstance(obj, nltk.tree.Tree)
+
+
+def _unique_descendants(node):
+    """
+    Returns the list of all nodes descended from the given node, where
+    there is only a single path of descent.
+    """
+    results = []
+    current = node
+    while current and _istree(current) and len(current) == 1:
+        current = current[0]
+        results.append(current)
+    return results
+
+
+def _before(node):
+    """
+    Returns the set of all nodes that are before the given node.
+    """
+    try:
+        pos = node.treeposition()
+        tree = node.root()
+    except AttributeError:
+        return []
+    return [tree[x] for x in tree.treepositions() if x[: len(pos)] < pos[: len(x)]]
+
+
+def _immediately_before(node):
+    """
+    Returns the set of all nodes that are immediately before the given
+    node.
+
+    Tree node A immediately precedes node B if the last terminal
+    symbol (word) produced by A immediately precedes the first
+    terminal symbol produced by B.
+    """
+    try:
+        pos = node.treeposition()
+        tree = node.root()
+    except AttributeError:
+        return []
+    # go "upwards" from pos until there is a place we can go to the left
+    idx = len(pos) - 1
+    while 0 <= idx and pos[idx] == 0:
+        idx -= 1
+    if idx < 0:
+        return []
+    pos = list(pos[: idx + 1])
+    pos[-1] -= 1
+    before = tree[pos]
+    return [before] + _rightmost_descendants(before)
+
+
+def _after(node):
+    """
+    Returns the set of all nodes that are after the given node.
+    """
+    try:
+        pos = node.treeposition()
+        tree = node.root()
+    except AttributeError:
+        return []
+    return [tree[x] for x in tree.treepositions() if x[: len(pos)] > pos[: len(x)]]
+
+
+def _immediately_after(node):
+    """
+    Returns the set of all nodes that are immediately after the given
+    node.
+
+    Tree node A immediately follows node B if the first terminal
+    symbol (word) produced by A immediately follows the last
+    terminal symbol produced by B.
+    """
+    try:
+        pos = node.treeposition()
+        tree = node.root()
+        current = node.parent()
+    except AttributeError:
+        return []
+    # go "upwards" from pos until there is a place we can go to the
+    # right
+    idx = len(pos) - 1
+    while 0 <= idx and pos[idx] == len(current) - 1:
+        idx -= 1
+        current = current.parent()
+    if idx < 0:
+        return []
+    pos = list(pos[: idx + 1])
+    pos[-1] += 1
+    after = tree[pos]
+    return [after] + _leftmost_descendants(after)
+
+
+def _tgrep_node_literal_value(node):
+    """
+    Gets the string value of a given parse tree node, for comparison
+    using the tgrep node literal predicates.
+    """
+    return node.label() if _istree(node) else str(node)
+
+
+def _tgrep_macro_use_action(_s, _l, tokens):
+    """
+    Builds a lambda function which looks up the macro name used.
+    """
+    assert len(tokens) == 1
+    assert tokens[0][0] == "@"
+    macro_name = tokens[0][1:]
+
+    def macro_use(n, m=None, l=None):
+        if m is None or macro_name not in m:
+            raise TgrepException(f"macro {macro_name} not defined")
+        return m[macro_name](n, m, l)
+
+    return macro_use
+
+
+def _tgrep_node_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    depending on the name of its node.
+    """
+    if tokens[0] == "'":
+        # strip initial apostrophe (tgrep2 print command)
+        tokens = tokens[1:]
+    if len(tokens) > 1:
+        # disjunctive definition of a node name
+        assert list(set(tokens[1::2])) == ["|"]
+        # recursively call self to interpret each node name definition
+        tokens = [_tgrep_node_action(None, None, [node]) for node in tokens[::2]]
+        # capture tokens and return the disjunction
+        return (lambda t: lambda n, m=None, l=None: any(f(n, m, l) for f in t))(tokens)
+    else:
+        if hasattr(tokens[0], "__call__"):
+            # this is a previously interpreted parenthetical node
+            # definition (lambda function)
+            return tokens[0]
+        elif tokens[0] == "*" or tokens[0] == "__":
+            return lambda n, m=None, l=None: True
+        elif tokens[0].startswith('"'):
+            assert tokens[0].endswith('"')
+            node_lit = tokens[0][1:-1].replace('\\"', '"').replace("\\\\", "\\")
+            return (
+                lambda s: lambda n, m=None, l=None: _tgrep_node_literal_value(n) == s
+            )(node_lit)
+        elif tokens[0].startswith("/"):
+            assert tokens[0].endswith("/")
+            node_lit = tokens[0][1:-1]
+            return (
+                lambda r: lambda n, m=None, l=None: r.search(
+                    _tgrep_node_literal_value(n)
+                )
+            )(re.compile(node_lit))
+        elif tokens[0].startswith("i@"):
+            node_func = _tgrep_node_action(_s, _l, [tokens[0][2:].lower()])
+            return (
+                lambda f: lambda n, m=None, l=None: f(
+                    _tgrep_node_literal_value(n).lower()
+                )
+            )(node_func)
+        else:
+            return (
+                lambda s: lambda n, m=None, l=None: _tgrep_node_literal_value(n) == s
+            )(tokens[0])
+
+
+def _tgrep_parens_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    from a parenthetical notation.
+    """
+    assert len(tokens) == 3
+    assert tokens[0] == "("
+    assert tokens[2] == ")"
+    return tokens[1]
+
+
+def _tgrep_nltk_tree_pos_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    which returns true if the node is located at a specific tree
+    position.
+    """
+    # recover the tuple from the parsed string
+    node_tree_position = tuple(int(x) for x in tokens if x.isdigit())
+    # capture the node's tree position
+    return (
+        lambda i: lambda n, m=None, l=None: (
+            hasattr(n, "treeposition") and n.treeposition() == i
+        )
+    )(node_tree_position)
+
+
+def _tgrep_relation_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    depending on its relation to other nodes in the tree.
+    """
+    # process negation first if needed
+    negated = False
+    if tokens[0] == "!":
+        negated = True
+        tokens = tokens[1:]
+    if tokens[0] == "[":
+        # process square-bracketed relation expressions
+        assert len(tokens) == 3
+        assert tokens[2] == "]"
+        retval = tokens[1]
+    else:
+        # process operator-node relation expressions
+        assert len(tokens) == 2
+        operator, predicate = tokens
+        # A < B       A is the parent of (immediately dominates) B.
+        if operator == "<":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and any(predicate(x, m, l) for x in n)
+            )
+        # A > B       A is the child of B.
+        elif operator == ">":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and bool(n.parent())
+                and predicate(n.parent(), m, l)
+            )
+        # A <, B      Synonymous with A <1 B.
+        elif operator == "<," or operator == "<1":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and bool(list(n)) and predicate(n[0], m, l)
+            )
+        # A >, B      Synonymous with A >1 B.
+        elif operator == ">," or operator == ">1":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and bool(n.parent())
+                and (n is n.parent()[0])
+                and predicate(n.parent(), m, l)
+            )
+        # A <N B      B is the Nth child of A (the first child is <1).
+        elif operator[0] == "<" and operator[1:].isdigit():
+            idx = int(operator[1:])
+            # capture the index parameter
+            retval = (
+                lambda i: lambda n, m=None, l=None: (
+                    _istree(n)
+                    and bool(list(n))
+                    and 0 <= i < len(n)
+                    and predicate(n[i], m, l)
+                )
+            )(idx - 1)
+        # A >N B      A is the Nth child of B (the first child is >1).
+        elif operator[0] == ">" and operator[1:].isdigit():
+            idx = int(operator[1:])
+            # capture the index parameter
+            retval = (
+                lambda i: lambda n, m=None, l=None: (
+                    hasattr(n, "parent")
+                    and bool(n.parent())
+                    and 0 <= i < len(n.parent())
+                    and (n is n.parent()[i])
+                    and predicate(n.parent(), m, l)
+                )
+            )(idx - 1)
+        # A <' B      B is the last child of A (also synonymous with A <-1 B).
+        # A <- B      B is the last child of A (synonymous with A <-1 B).
+        elif operator == "<'" or operator == "<-" or operator == "<-1":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and bool(list(n)) and predicate(n[-1], m, l)
+            )
+        # A >' B      A is the last child of B (also synonymous with A >-1 B).
+        # A >- B      A is the last child of B (synonymous with A >-1 B).
+        elif operator == ">'" or operator == ">-" or operator == ">-1":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and bool(n.parent())
+                and (n is n.parent()[-1])
+                and predicate(n.parent(), m, l)
+            )
+        # A <-N B 	  B is the N th-to-last child of A (the last child is <-1).
+        elif operator[:2] == "<-" and operator[2:].isdigit():
+            idx = -int(operator[2:])
+            # capture the index parameter
+            retval = (
+                lambda i: lambda n, m=None, l=None: (
+                    _istree(n)
+                    and bool(list(n))
+                    and 0 <= (i + len(n)) < len(n)
+                    and predicate(n[i + len(n)], m, l)
+                )
+            )(idx)
+        # A >-N B 	  A is the N th-to-last child of B (the last child is >-1).
+        elif operator[:2] == ">-" and operator[2:].isdigit():
+            idx = -int(operator[2:])
+            # capture the index parameter
+            retval = (
+                lambda i: lambda n, m=None, l=None: (
+                    hasattr(n, "parent")
+                    and bool(n.parent())
+                    and 0 <= (i + len(n.parent())) < len(n.parent())
+                    and (n is n.parent()[i + len(n.parent())])
+                    and predicate(n.parent(), m, l)
+                )
+            )(idx)
+        # A <: B      B is the only child of A
+        elif operator == "<:":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and len(n) == 1 and predicate(n[0], m, l)
+            )
+        # A >: B      A is the only child of B.
+        elif operator == ">:":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and bool(n.parent())
+                and len(n.parent()) == 1
+                and predicate(n.parent(), m, l)
+            )
+        # A << B      A dominates B (A is an ancestor of B).
+        elif operator == "<<":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and any(predicate(x, m, l) for x in _descendants(n))
+            )
+        # A >> B      A is dominated by B (A is a descendant of B).
+        elif operator == ">>":
+            retval = lambda n, m=None, l=None: any(
+                predicate(x, m, l) for x in ancestors(n)
+            )
+        # A <<, B     B is a left-most descendant of A.
+        elif operator == "<<," or operator == "<<1":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and any(predicate(x, m, l) for x in _leftmost_descendants(n))
+            )
+        # A >>, B     A is a left-most descendant of B.
+        elif operator == ">>,":
+            retval = lambda n, m=None, l=None: any(
+                (predicate(x, m, l) and n in _leftmost_descendants(x))
+                for x in ancestors(n)
+            )
+        # A <<' B     B is a right-most descendant of A.
+        elif operator == "<<'":
+            retval = lambda n, m=None, l=None: (
+                _istree(n)
+                and any(predicate(x, m, l) for x in _rightmost_descendants(n))
+            )
+        # A >>' B     A is a right-most descendant of B.
+        elif operator == ">>'":
+            retval = lambda n, m=None, l=None: any(
+                (predicate(x, m, l) and n in _rightmost_descendants(x))
+                for x in ancestors(n)
+            )
+        # A <<: B     There is a single path of descent from A and B is on it.
+        elif operator == "<<:":
+            retval = lambda n, m=None, l=None: (
+                _istree(n) and any(predicate(x, m, l) for x in _unique_descendants(n))
+            )
+        # A >>: B     There is a single path of descent from B and A is on it.
+        elif operator == ">>:":
+            retval = lambda n, m=None, l=None: any(
+                predicate(x, m, l) for x in unique_ancestors(n)
+            )
+        # A . B       A immediately precedes B.
+        elif operator == ".":
+            retval = lambda n, m=None, l=None: any(
+                predicate(x, m, l) for x in _immediately_after(n)
+            )
+        # A , B       A immediately follows B.
+        elif operator == ",":
+            retval = lambda n, m=None, l=None: any(
+                predicate(x, m, l) for x in _immediately_before(n)
+            )
+        # A .. B      A precedes B.
+        elif operator == "..":
+            retval = lambda n, m=None, l=None: any(
+                predicate(x, m, l) for x in _after(n)
+            )
+        # A ,, B      A follows B.
+        elif operator == ",,":
+            retval = lambda n, m=None, l=None: any(
+                predicate(x, m, l) for x in _before(n)
+            )
+        # A $ B       A is a sister of B (and A != B).
+        elif operator == "$" or operator == "%":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and bool(n.parent())
+                and any(predicate(x, m, l) for x in n.parent() if x is not n)
+            )
+        # A $. B      A is a sister of and immediately precedes B.
+        elif operator == "$." or operator == "%.":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "right_sibling")
+                and bool(n.right_sibling())
+                and predicate(n.right_sibling(), m, l)
+            )
+        # A $, B      A is a sister of and immediately follows B.
+        elif operator == "$," or operator == "%,":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "left_sibling")
+                and bool(n.left_sibling())
+                and predicate(n.left_sibling(), m, l)
+            )
+        # A $.. B     A is a sister of and precedes B.
+        elif operator == "$.." or operator == "%..":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and hasattr(n, "parent_index")
+                and bool(n.parent())
+                and any(predicate(x, m, l) for x in n.parent()[n.parent_index() + 1 :])
+            )
+        # A $,, B     A is a sister of and follows B.
+        elif operator == "$,," or operator == "%,,":
+            retval = lambda n, m=None, l=None: (
+                hasattr(n, "parent")
+                and hasattr(n, "parent_index")
+                and bool(n.parent())
+                and any(predicate(x, m, l) for x in n.parent()[: n.parent_index()])
+            )
+        else:
+            raise TgrepException(f'cannot interpret tgrep operator "{operator}"')
+    # now return the built function
+    if negated:
+        return (lambda r: (lambda n, m=None, l=None: not r(n, m, l)))(retval)
+    else:
+        return retval
+
+
+def _tgrep_conjunction_action(_s, _l, tokens, join_char="&"):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    from the conjunction of several other such lambda functions.
+
+    This is prototypically called for expressions like
+    (`tgrep_rel_conjunction`)::
+
+        < NP & < AP < VP
+
+    where tokens is a list of predicates representing the relations
+    (`< NP`, `< AP`, and `< VP`), possibly with the character `&`
+    included (as in the example here).
+
+    This is also called for expressions like (`tgrep_node_expr2`)::
+
+        NP < NN
+        S=s < /NP/=n : s < /VP/=v : n .. v
+
+    tokens[0] is a tgrep_expr predicate; tokens[1:] are an (optional)
+    list of segmented patterns (`tgrep_expr_labeled`, processed by
+    `_tgrep_segmented_pattern_action`).
+    """
+    # filter out the ampersand
+    tokens = [x for x in tokens if x != join_char]
+    if len(tokens) == 1:
+        return tokens[0]
+    else:
+        return (
+            lambda ts: lambda n, m=None, l=None: all(
+                predicate(n, m, l) for predicate in ts
+            )
+        )(tokens)
+
+
+def _tgrep_segmented_pattern_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a segmented pattern.
+
+    Called for expressions like (`tgrep_expr_labeled`)::
+
+        =s .. =v < =n
+
+    This is a segmented pattern, a tgrep2 expression which begins with
+    a node label.
+
+    The problem is that for segemented_pattern_action (': =v < =s'),
+    the first element (in this case, =v) is specifically selected by
+    virtue of matching a particular node in the tree; to retrieve
+    the node, we need the label, not a lambda function.  For node
+    labels inside a tgrep_node_expr, we need a lambda function which
+    returns true if the node visited is the same as =v.
+
+    We solve this by creating two copies of a node_label_use in the
+    grammar; the label use inside a tgrep_expr_labeled has a separate
+    parse action to the pred use inside a node_expr.  See
+    `_tgrep_node_label_use_action` and
+    `_tgrep_node_label_pred_use_action`.
+    """
+    # tokens[0] is a string containing the node label
+    node_label = tokens[0]
+    # tokens[1:] is an (optional) list of predicates which must all
+    # hold of the bound node
+    reln_preds = tokens[1:]
+
+    def pattern_segment_pred(n, m=None, l=None):
+        """This predicate function ignores its node argument."""
+        # look up the bound node using its label
+        if l is None or node_label not in l:
+            raise TgrepException(f"node_label ={node_label} not bound in pattern")
+        node = l[node_label]
+        # match the relation predicates against the node
+        return all(pred(node, m, l) for pred in reln_preds)
+
+    return pattern_segment_pred
+
+
+def _tgrep_node_label_use_action(_s, _l, tokens):
+    """
+    Returns the node label used to begin a tgrep_expr_labeled.  See
+    `_tgrep_segmented_pattern_action`.
+
+    Called for expressions like (`tgrep_node_label_use`)::
+
+        =s
+
+    when they appear as the first element of a `tgrep_expr_labeled`
+    expression (see `_tgrep_segmented_pattern_action`).
+
+    It returns the node label.
+    """
+    assert len(tokens) == 1
+    assert tokens[0].startswith("=")
+    return tokens[0][1:]
+
+
+def _tgrep_node_label_pred_use_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    which describes the use of a previously bound node label.
+
+    Called for expressions like (`tgrep_node_label_use_pred`)::
+
+        =s
+
+    when they appear inside a tgrep_node_expr (for example, inside a
+    relation).  The predicate returns true if and only if its node
+    argument is identical the the node looked up in the node label
+    dictionary using the node's label.
+    """
+    assert len(tokens) == 1
+    assert tokens[0].startswith("=")
+    node_label = tokens[0][1:]
+
+    def node_label_use_pred(n, m=None, l=None):
+        # look up the bound node using its label
+        if l is None or node_label not in l:
+            raise TgrepException(f"node_label ={node_label} not bound in pattern")
+        node = l[node_label]
+        # truth means the given node is this node
+        return n is node
+
+    return node_label_use_pred
+
+
+def _tgrep_bind_node_label_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    which can optionally bind a matching node into the tgrep2 string's
+    label_dict.
+
+    Called for expressions like (`tgrep_node_expr2`)::
+
+        /NP/
+        @NP=n
+    """
+    # tokens[0] is a tgrep_node_expr
+    if len(tokens) == 1:
+        return tokens[0]
+    else:
+        # if present, tokens[1] is the character '=', and tokens[2] is
+        # a tgrep_node_label, a string value containing the node label
+        assert len(tokens) == 3
+        assert tokens[1] == "="
+        node_pred = tokens[0]
+        node_label = tokens[2]
+
+        def node_label_bind_pred(n, m=None, l=None):
+            if node_pred(n, m, l):
+                # bind `n` into the dictionary `l`
+                if l is None:
+                    raise TgrepException(
+                        "cannot bind node_label {}: label_dict is None".format(
+                            node_label
+                        )
+                    )
+                l[node_label] = n
+                return True
+            else:
+                return False
+
+        return node_label_bind_pred
+
+
+def _tgrep_rel_disjunction_action(_s, _l, tokens):
+    """
+    Builds a lambda function representing a predicate on a tree node
+    from the disjunction of several other such lambda functions.
+    """
+    # filter out the pipe
+    tokens = [x for x in tokens if x != "|"]
+    if len(tokens) == 1:
+        return tokens[0]
+    elif len(tokens) == 2:
+        return (lambda a, b: lambda n, m=None, l=None: a(n, m, l) or b(n, m, l))(
+            tokens[0], tokens[1]
+        )
+
+
+def _macro_defn_action(_s, _l, tokens):
+    """
+    Builds a dictionary structure which defines the given macro.
+    """
+    assert len(tokens) == 3
+    assert tokens[0] == "@"
+    return {tokens[1]: tokens[2]}
+
+
+def _tgrep_exprs_action(_s, _l, tokens):
+    """
+    This is the top-lebel node in a tgrep2 search string; the
+    predicate function it returns binds together all the state of a
+    tgrep2 search string.
+
+    Builds a lambda function representing a predicate on a tree node
+    from the disjunction of several tgrep expressions.  Also handles
+    macro definitions and macro name binding, and node label
+    definitions and node label binding.
+    """
+    if len(tokens) == 1:
+        return lambda n, m=None, l=None: tokens[0](n, None, {})
+    # filter out all the semicolons
+    tokens = [x for x in tokens if x != ";"]
+    # collect all macro definitions
+    macro_dict = {}
+    macro_defs = [tok for tok in tokens if isinstance(tok, dict)]
+    for macro_def in macro_defs:
+        macro_dict.update(macro_def)
+    # collect all tgrep expressions
+    tgrep_exprs = [tok for tok in tokens if not isinstance(tok, dict)]
+    # create a new scope for the node label dictionary
+    def top_level_pred(n, m=macro_dict, l=None):
+        label_dict = {}
+        # bind macro definitions and OR together all tgrep_exprs
+        return any(predicate(n, m, label_dict) for predicate in tgrep_exprs)
+
+    return top_level_pred
+
+
+def _build_tgrep_parser(set_parse_actions=True):
+    """
+    Builds a pyparsing-based parser object for tokenizing and
+    interpreting tgrep search strings.
+    """
+    tgrep_op = pyparsing.Optional("!") + pyparsing.Regex("[$%,.<>][%,.<>0-9-':]*")
+    tgrep_qstring = pyparsing.QuotedString(
+        quoteChar='"', escChar="\\", unquoteResults=False
+    )
+    tgrep_node_regex = pyparsing.QuotedString(
+        quoteChar="/", escChar="\\", unquoteResults=False
+    )
+    tgrep_qstring_icase = pyparsing.Regex('i@\\"(?:[^"\\n\\r\\\\]|(?:\\\\.))*\\"')
+    tgrep_node_regex_icase = pyparsing.Regex("i@\\/(?:[^/\\n\\r\\\\]|(?:\\\\.))*\\/")
+    tgrep_node_literal = pyparsing.Regex("[^][ \r\t\n;:.,&|<>()$!@%'^=]+")
+    tgrep_expr = pyparsing.Forward()
+    tgrep_relations = pyparsing.Forward()
+    tgrep_parens = pyparsing.Literal("(") + tgrep_expr + ")"
+    tgrep_nltk_tree_pos = (
+        pyparsing.Literal("N(")
+        + pyparsing.Optional(
+            pyparsing.Word(pyparsing.nums)
+            + ","
+            + pyparsing.Optional(
+                pyparsing.delimitedList(pyparsing.Word(pyparsing.nums), delim=",")
+                + pyparsing.Optional(",")
+            )
+        )
+        + ")"
+    )
+    tgrep_node_label = pyparsing.Regex("[A-Za-z0-9]+")
+    tgrep_node_label_use = pyparsing.Combine("=" + tgrep_node_label)
+    # see _tgrep_segmented_pattern_action
+    tgrep_node_label_use_pred = tgrep_node_label_use.copy()
+    macro_name = pyparsing.Regex("[^];:.,&|<>()[$!@%'^=\r\t\n ]+")
+    macro_name.setWhitespaceChars("")
+    macro_use = pyparsing.Combine("@" + macro_name)
+    tgrep_node_expr = (
+        tgrep_node_label_use_pred
+        | macro_use
+        | tgrep_nltk_tree_pos
+        | tgrep_qstring_icase
+        | tgrep_node_regex_icase
+        | tgrep_qstring
+        | tgrep_node_regex
+        | "*"
+        | tgrep_node_literal
+    )
+    tgrep_node_expr2 = (
+        tgrep_node_expr
+        + pyparsing.Literal("=").setWhitespaceChars("")
+        + tgrep_node_label.copy().setWhitespaceChars("")
+    ) | tgrep_node_expr
+    tgrep_node = tgrep_parens | (
+        pyparsing.Optional("'")
+        + tgrep_node_expr2
+        + pyparsing.ZeroOrMore("|" + tgrep_node_expr)
+    )
+    tgrep_brackets = pyparsing.Optional("!") + "[" + tgrep_relations + "]"
+    tgrep_relation = tgrep_brackets | (tgrep_op + tgrep_node)
+    tgrep_rel_conjunction = pyparsing.Forward()
+    tgrep_rel_conjunction << (
+        tgrep_relation
+        + pyparsing.ZeroOrMore(pyparsing.Optional("&") + tgrep_rel_conjunction)
+    )
+    tgrep_relations << tgrep_rel_conjunction + pyparsing.ZeroOrMore(
+        "|" + tgrep_relations
+    )
+    tgrep_expr << tgrep_node + pyparsing.Optional(tgrep_relations)
+    tgrep_expr_labeled = tgrep_node_label_use + pyparsing.Optional(tgrep_relations)
+    tgrep_expr2 = tgrep_expr + pyparsing.ZeroOrMore(":" + tgrep_expr_labeled)
+    macro_defn = (
+        pyparsing.Literal("@") + pyparsing.White().suppress() + macro_name + tgrep_expr2
+    )
+    tgrep_exprs = (
+        pyparsing.Optional(macro_defn + pyparsing.ZeroOrMore(";" + macro_defn) + ";")
+        + tgrep_expr2
+        + pyparsing.ZeroOrMore(";" + (macro_defn | tgrep_expr2))
+        + pyparsing.ZeroOrMore(";").suppress()
+    )
+    if set_parse_actions:
+        tgrep_node_label_use.setParseAction(_tgrep_node_label_use_action)
+        tgrep_node_label_use_pred.setParseAction(_tgrep_node_label_pred_use_action)
+        macro_use.setParseAction(_tgrep_macro_use_action)
+        tgrep_node.setParseAction(_tgrep_node_action)
+        tgrep_node_expr2.setParseAction(_tgrep_bind_node_label_action)
+        tgrep_parens.setParseAction(_tgrep_parens_action)
+        tgrep_nltk_tree_pos.setParseAction(_tgrep_nltk_tree_pos_action)
+        tgrep_relation.setParseAction(_tgrep_relation_action)
+        tgrep_rel_conjunction.setParseAction(_tgrep_conjunction_action)
+        tgrep_relations.setParseAction(_tgrep_rel_disjunction_action)
+        macro_defn.setParseAction(_macro_defn_action)
+        # the whole expression is also the conjunction of two
+        # predicates: the first node predicate, and the remaining
+        # relation predicates
+        tgrep_expr.setParseAction(_tgrep_conjunction_action)
+        tgrep_expr_labeled.setParseAction(_tgrep_segmented_pattern_action)
+        tgrep_expr2.setParseAction(
+            functools.partial(_tgrep_conjunction_action, join_char=":")
+        )
+        tgrep_exprs.setParseAction(_tgrep_exprs_action)
+    return tgrep_exprs.ignore("#" + pyparsing.restOfLine)
+
+
+def tgrep_tokenize(tgrep_string):
+    """
+    Tokenizes a TGrep search string into separate tokens.
+    """
+    parser = _build_tgrep_parser(False)
+    if isinstance(tgrep_string, bytes):
+        tgrep_string = tgrep_string.decode()
+    return list(parser.parseString(tgrep_string))
+
+
+def tgrep_compile(tgrep_string):
+    """
+    Parses (and tokenizes, if necessary) a TGrep search string into a
+    lambda function.
+    """
+    parser = _build_tgrep_parser(True)
+    if isinstance(tgrep_string, bytes):
+        tgrep_string = tgrep_string.decode()
+    return list(parser.parseString(tgrep_string, parseAll=True))[0]
+
+
+def treepositions_no_leaves(tree):
+    """
+    Returns all the tree positions in the given tree which are not
+    leaf nodes.
+    """
+    treepositions = tree.treepositions()
+    # leaves are treeposition tuples that are not prefixes of any
+    # other treeposition
+    prefixes = set()
+    for pos in treepositions:
+        for length in range(len(pos)):
+            prefixes.add(pos[:length])
+    return [pos for pos in treepositions if pos in prefixes]
+
+
+def tgrep_positions(pattern, trees, search_leaves=True):
+    """
+    Return the tree positions in the trees which match the given pattern.
+
+    :param pattern: a tgrep search pattern
+    :type pattern: str or output of tgrep_compile()
+    :param trees: a sequence of NLTK trees (usually ParentedTrees)
+    :type trees: iter(ParentedTree) or iter(Tree)
+    :param search_leaves: whether to return matching leaf nodes
+    :type search_leaves: bool
+    :rtype: iter(tree positions)
+    """
+
+    if isinstance(pattern, (bytes, str)):
+        pattern = tgrep_compile(pattern)
+
+    for tree in trees:
+        try:
+            if search_leaves:
+                positions = tree.treepositions()
+            else:
+                positions = treepositions_no_leaves(tree)
+            yield [position for position in positions if pattern(tree[position])]
+        except AttributeError:
+            yield []
+
+
+def tgrep_nodes(pattern, trees, search_leaves=True):
+    """
+    Return the tree nodes in the trees which match the given pattern.
+
+    :param pattern: a tgrep search pattern
+    :type pattern: str or output of tgrep_compile()
+    :param trees: a sequence of NLTK trees (usually ParentedTrees)
+    :type trees: iter(ParentedTree) or iter(Tree)
+    :param search_leaves: whether to return matching leaf nodes
+    :type search_leaves: bool
+    :rtype: iter(tree nodes)
+    """
+
+    if isinstance(pattern, (bytes, str)):
+        pattern = tgrep_compile(pattern)
+
+    for tree in trees:
+        try:
+            if search_leaves:
+                positions = tree.treepositions()
+            else:
+                positions = treepositions_no_leaves(tree)
+            yield [tree[position] for position in positions if pattern(tree[position])]
+        except AttributeError:
+            yield []

llmeval-env/lib/python3.10/site-packages/nltk/toolbox.py

@@ -0,0 +1,524 @@
+# Natural Language Toolkit: Toolbox Reader
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Greg Aumann <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Module for reading, writing and manipulating
+Toolbox databases and settings files.
+"""
+
+import codecs
+import re
+from io import StringIO
+from xml.etree.ElementTree import Element, ElementTree, SubElement, TreeBuilder
+
+from nltk.data import PathPointer, find
+
+
+class StandardFormat:
+    """
+    Class for reading and processing standard format marker files and strings.
+    """
+
+    def __init__(self, filename=None, encoding=None):
+        self._encoding = encoding
+        if filename is not None:
+            self.open(filename)
+
+    def open(self, sfm_file):
+        """
+        Open a standard format marker file for sequential reading.
+
+        :param sfm_file: name of the standard format marker input file
+        :type sfm_file: str
+        """
+        if isinstance(sfm_file, PathPointer):
+            self._file = sfm_file.open(self._encoding)
+        else:
+            self._file = codecs.open(sfm_file, "r", self._encoding)
+
+    def open_string(self, s):
+        """
+        Open a standard format marker string for sequential reading.
+
+        :param s: string to parse as a standard format marker input file
+        :type s: str
+        """
+        self._file = StringIO(s)
+
+    def raw_fields(self):
+        """
+        Return an iterator that returns the next field in a (marker, value)
+        tuple. Linebreaks and trailing white space are preserved except
+        for the final newline in each field.
+
+        :rtype: iter(tuple(str, str))
+        """
+        join_string = "\n"
+        line_regexp = r"^%s(?:\\(\S+)\s*)?(.*)$"
+        # discard a BOM in the first line
+        first_line_pat = re.compile(line_regexp % "(?:\xef\xbb\xbf)?")
+        line_pat = re.compile(line_regexp % "")
+        # need to get first line outside the loop for correct handling
+        # of the first marker if it spans multiple lines
+        file_iter = iter(self._file)
+        # PEP 479, prevent RuntimeError when StopIteration is raised inside generator
+        try:
+            line = next(file_iter)
+        except StopIteration:
+            # no more data is available, terminate the generator
+            return
+        mobj = re.match(first_line_pat, line)
+        mkr, line_value = mobj.groups()
+        value_lines = [line_value]
+        self.line_num = 0
+        for line in file_iter:
+            self.line_num += 1
+            mobj = re.match(line_pat, line)
+            line_mkr, line_value = mobj.groups()
+            if line_mkr:
+                yield (mkr, join_string.join(value_lines))
+                mkr = line_mkr
+                value_lines = [line_value]
+            else:
+                value_lines.append(line_value)
+        self.line_num += 1
+        yield (mkr, join_string.join(value_lines))
+
+    def fields(
+        self,
+        strip=True,
+        unwrap=True,
+        encoding=None,
+        errors="strict",
+        unicode_fields=None,
+    ):
+        """
+        Return an iterator that returns the next field in a ``(marker, value)``
+        tuple, where ``marker`` and ``value`` are unicode strings if an ``encoding``
+        was specified in the ``fields()`` method. Otherwise they are non-unicode strings.
+
+        :param strip: strip trailing whitespace from the last line of each field
+        :type strip: bool
+        :param unwrap: Convert newlines in a field to spaces.
+        :type unwrap: bool
+        :param encoding: Name of an encoding to use. If it is specified then
+            the ``fields()`` method returns unicode strings rather than non
+            unicode strings.
+        :type encoding: str or None
+        :param errors: Error handling scheme for codec. Same as the ``decode()``
+            builtin string method.
+        :type errors: str
+        :param unicode_fields: Set of marker names whose values are UTF-8 encoded.
+            Ignored if encoding is None. If the whole file is UTF-8 encoded set
+            ``encoding='utf8'`` and leave ``unicode_fields`` with its default
+            value of None.
+        :type unicode_fields: sequence
+        :rtype: iter(tuple(str, str))
+        """
+        if encoding is None and unicode_fields is not None:
+            raise ValueError("unicode_fields is set but not encoding.")
+        unwrap_pat = re.compile(r"\n+")
+        for mkr, val in self.raw_fields():
+            if unwrap:
+                val = unwrap_pat.sub(" ", val)
+            if strip:
+                val = val.rstrip()
+            yield (mkr, val)
+
+    def close(self):
+        """Close a previously opened standard format marker file or string."""
+        self._file.close()
+        try:
+            del self.line_num
+        except AttributeError:
+            pass
+
+
+class ToolboxData(StandardFormat):
+    def parse(self, grammar=None, **kwargs):
+        if grammar:
+            return self._chunk_parse(grammar=grammar, **kwargs)
+        else:
+            return self._record_parse(**kwargs)
+
+    def _record_parse(self, key=None, **kwargs):
+        r"""
+        Returns an element tree structure corresponding to a toolbox data file with
+        all markers at the same level.
+
+        Thus the following Toolbox database::
+            \_sh v3.0  400  Rotokas Dictionary
+            \_DateStampHasFourDigitYear
+
+            \lx kaa
+            \ps V.A
+            \ge gag
+            \gp nek i pas
+
+            \lx kaa
+            \ps V.B
+            \ge strangle
+            \gp pasim nek
+
+        after parsing will end up with the same structure (ignoring the extra
+        whitespace) as the following XML fragment after being parsed by
+        ElementTree::
+            <toolbox_data>
+                <header>
+                    <_sh>v3.0  400  Rotokas Dictionary</_sh>
+                    <_DateStampHasFourDigitYear/>
+                </header>
+
+                <record>
+                    <lx>kaa</lx>
+                    <ps>V.A</ps>
+                    <ge>gag</ge>
+                    <gp>nek i pas</gp>
+                </record>
+
+                <record>
+                    <lx>kaa</lx>
+                    <ps>V.B</ps>
+                    <ge>strangle</ge>
+                    <gp>pasim nek</gp>
+                </record>
+            </toolbox_data>
+
+        :param key: Name of key marker at the start of each record. If set to
+            None (the default value) the first marker that doesn't begin with
+            an underscore is assumed to be the key.
+        :type key: str
+        :param kwargs: Keyword arguments passed to ``StandardFormat.fields()``
+        :type kwargs: dict
+        :rtype: ElementTree._ElementInterface
+        :return: contents of toolbox data divided into header and records
+        """
+        builder = TreeBuilder()
+        builder.start("toolbox_data", {})
+        builder.start("header", {})
+        in_records = False
+        for mkr, value in self.fields(**kwargs):
+            if key is None and not in_records and mkr[0] != "_":
+                key = mkr
+            if mkr == key:
+                if in_records:
+                    builder.end("record")
+                else:
+                    builder.end("header")
+                    in_records = True
+                builder.start("record", {})
+            builder.start(mkr, {})
+            builder.data(value)
+            builder.end(mkr)
+        if in_records:
+            builder.end("record")
+        else:
+            builder.end("header")
+        builder.end("toolbox_data")
+        return builder.close()
+
+    def _tree2etree(self, parent):
+        from nltk.tree import Tree
+
+        root = Element(parent.label())
+        for child in parent:
+            if isinstance(child, Tree):
+                root.append(self._tree2etree(child))
+            else:
+                text, tag = child
+                e = SubElement(root, tag)
+                e.text = text
+        return root
+
+    def _chunk_parse(self, grammar=None, root_label="record", trace=0, **kwargs):
+        """
+        Returns an element tree structure corresponding to a toolbox data file
+        parsed according to the chunk grammar.
+
+        :type grammar: str
+        :param grammar: Contains the chunking rules used to parse the
+            database.  See ``chunk.RegExp`` for documentation.
+        :type root_label: str
+        :param root_label: The node value that should be used for the
+            top node of the chunk structure.
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            ``1`` will generate normal tracing output; and ``2`` or
+            higher will generate verbose tracing output.
+        :type kwargs: dict
+        :param kwargs: Keyword arguments passed to ``toolbox.StandardFormat.fields()``
+        :rtype: ElementTree._ElementInterface
+        """
+        from nltk import chunk
+        from nltk.tree import Tree
+
+        cp = chunk.RegexpParser(grammar, root_label=root_label, trace=trace)
+        db = self.parse(**kwargs)
+        tb_etree = Element("toolbox_data")
+        header = db.find("header")
+        tb_etree.append(header)
+        for record in db.findall("record"):
+            parsed = cp.parse([(elem.text, elem.tag) for elem in record])
+            tb_etree.append(self._tree2etree(parsed))
+        return tb_etree
+
+
+_is_value = re.compile(r"\S")
+
+
+def to_sfm_string(tree, encoding=None, errors="strict", unicode_fields=None):
+    """
+    Return a string with a standard format representation of the toolbox
+    data in tree (tree can be a toolbox database or a single record).
+
+    :param tree: flat representation of toolbox data (whole database or single record)
+    :type tree: ElementTree._ElementInterface
+    :param encoding: Name of an encoding to use.
+    :type encoding: str
+    :param errors: Error handling scheme for codec. Same as the ``encode()``
+        builtin string method.
+    :type errors: str
+    :param unicode_fields:
+    :type unicode_fields: dict(str) or set(str)
+    :rtype: str
+    """
+    if tree.tag == "record":
+        root = Element("toolbox_data")
+        root.append(tree)
+        tree = root
+
+    if tree.tag != "toolbox_data":
+        raise ValueError("not a toolbox_data element structure")
+    if encoding is None and unicode_fields is not None:
+        raise ValueError(
+            "if encoding is not specified then neither should unicode_fields"
+        )
+    l = []
+    for rec in tree:
+        l.append("\n")
+        for field in rec:
+            mkr = field.tag
+            value = field.text
+            if encoding is not None:
+                if unicode_fields is not None and mkr in unicode_fields:
+                    cur_encoding = "utf8"
+                else:
+                    cur_encoding = encoding
+                if re.search(_is_value, value):
+                    l.append((f"\\{mkr} {value}\n").encode(cur_encoding, errors))
+                else:
+                    l.append((f"\\{mkr}{value}\n").encode(cur_encoding, errors))
+            else:
+                if re.search(_is_value, value):
+                    l.append(f"\\{mkr} {value}\n")
+                else:
+                    l.append(f"\\{mkr}{value}\n")
+    return "".join(l[1:])
+
+
+class ToolboxSettings(StandardFormat):
+    """This class is the base class for settings files."""
+
+    def __init__(self):
+        super().__init__()
+
+    def parse(self, encoding=None, errors="strict", **kwargs):
+        """
+        Return the contents of toolbox settings file with a nested structure.
+
+        :param encoding: encoding used by settings file
+        :type encoding: str
+        :param errors: Error handling scheme for codec. Same as ``decode()`` builtin method.
+        :type errors: str
+        :param kwargs: Keyword arguments passed to ``StandardFormat.fields()``
+        :type kwargs: dict
+        :rtype: ElementTree._ElementInterface
+        """
+        builder = TreeBuilder()
+        for mkr, value in self.fields(encoding=encoding, errors=errors, **kwargs):
+            # Check whether the first char of the field marker
+            # indicates a block start (+) or end (-)
+            block = mkr[0]
+            if block in ("+", "-"):
+                mkr = mkr[1:]
+            else:
+                block = None
+            # Build tree on the basis of block char
+            if block == "+":
+                builder.start(mkr, {})
+                builder.data(value)
+            elif block == "-":
+                builder.end(mkr)
+            else:
+                builder.start(mkr, {})
+                builder.data(value)
+                builder.end(mkr)
+        return builder.close()
+
+
+def to_settings_string(tree, encoding=None, errors="strict", unicode_fields=None):
+    # write XML to file
+    l = list()
+    _to_settings_string(
+        tree.getroot(),
+        l,
+        encoding=encoding,
+        errors=errors,
+        unicode_fields=unicode_fields,
+    )
+    return "".join(l)
+
+
+def _to_settings_string(node, l, **kwargs):
+    # write XML to file
+    tag = node.tag
+    text = node.text
+    if len(node) == 0:
+        if text:
+            l.append(f"\\{tag} {text}\n")
+        else:
+            l.append("\\%s\n" % tag)
+    else:
+        if text:
+            l.append(f"\\+{tag} {text}\n")
+        else:
+            l.append("\\+%s\n" % tag)
+        for n in node:
+            _to_settings_string(n, l, **kwargs)
+        l.append("\\-%s\n" % tag)
+    return
+
+
+def remove_blanks(elem):
+    """
+    Remove all elements and subelements with no text and no child elements.
+
+    :param elem: toolbox data in an elementtree structure
+    :type elem: ElementTree._ElementInterface
+    """
+    out = list()
+    for child in elem:
+        remove_blanks(child)
+        if child.text or len(child) > 0:
+            out.append(child)
+    elem[:] = out
+
+
+def add_default_fields(elem, default_fields):
+    """
+    Add blank elements and subelements specified in default_fields.
+
+    :param elem: toolbox data in an elementtree structure
+    :type elem: ElementTree._ElementInterface
+    :param default_fields: fields to add to each type of element and subelement
+    :type default_fields: dict(tuple)
+    """
+    for field in default_fields.get(elem.tag, []):
+        if elem.find(field) is None:
+            SubElement(elem, field)
+    for child in elem:
+        add_default_fields(child, default_fields)
+
+
+def sort_fields(elem, field_orders):
+    """
+    Sort the elements and subelements in order specified in field_orders.
+
+    :param elem: toolbox data in an elementtree structure
+    :type elem: ElementTree._ElementInterface
+    :param field_orders: order of fields for each type of element and subelement
+    :type field_orders: dict(tuple)
+    """
+    order_dicts = dict()
+    for field, order in field_orders.items():
+        order_dicts[field] = order_key = dict()
+        for i, subfield in enumerate(order):
+            order_key[subfield] = i
+    _sort_fields(elem, order_dicts)
+
+
+def _sort_fields(elem, orders_dicts):
+    """sort the children of elem"""
+    try:
+        order = orders_dicts[elem.tag]
+    except KeyError:
+        pass
+    else:
+        tmp = sorted(
+            ((order.get(child.tag, 1e9), i), child) for i, child in enumerate(elem)
+        )
+        elem[:] = [child for key, child in tmp]
+    for child in elem:
+        if len(child):
+            _sort_fields(child, orders_dicts)
+
+
+def add_blank_lines(tree, blanks_before, blanks_between):
+    """
+    Add blank lines before all elements and subelements specified in blank_before.
+
+    :param elem: toolbox data in an elementtree structure
+    :type elem: ElementTree._ElementInterface
+    :param blank_before: elements and subelements to add blank lines before
+    :type blank_before: dict(tuple)
+    """
+    try:
+        before = blanks_before[tree.tag]
+        between = blanks_between[tree.tag]
+    except KeyError:
+        for elem in tree:
+            if len(elem):
+                add_blank_lines(elem, blanks_before, blanks_between)
+    else:
+        last_elem = None
+        for elem in tree:
+            tag = elem.tag
+            if last_elem is not None and last_elem.tag != tag:
+                if tag in before and last_elem is not None:
+                    e = last_elem.getiterator()[-1]
+                    e.text = (e.text or "") + "\n"
+            else:
+                if tag in between:
+                    e = last_elem.getiterator()[-1]
+                    e.text = (e.text or "") + "\n"
+            if len(elem):
+                add_blank_lines(elem, blanks_before, blanks_between)
+            last_elem = elem
+
+
+def demo():
+    from itertools import islice
+
+    #    zip_path = find('corpora/toolbox.zip')
+    #    lexicon = ToolboxData(ZipFilePathPointer(zip_path, 'toolbox/rotokas.dic')).parse()
+    file_path = find("corpora/toolbox/rotokas.dic")
+    lexicon = ToolboxData(file_path).parse()
+    print("first field in fourth record:")
+    print(lexicon[3][0].tag)
+    print(lexicon[3][0].text)
+
+    print("\nfields in sequential order:")
+    for field in islice(lexicon.find("record"), 10):
+        print(field.tag, field.text)
+
+    print("\nlx fields:")
+    for field in islice(lexicon.findall("record/lx"), 10):
+        print(field.text)
+
+    settings = ToolboxSettings()
+    file_path = find("corpora/toolbox/MDF/MDF_AltH.typ")
+    settings.open(file_path)
+    #    settings.open(ZipFilePathPointer(zip_path, entry='toolbox/MDF/MDF_AltH.typ'))
+    tree = settings.parse(unwrap=False, encoding="cp1252")
+    print(tree.find("expset/expMDF/rtfPageSetup/paperSize").text)
+    settings_tree = ElementTree(tree)
+    print(to_settings_string(settings_tree).encode("utf8"))
+
+
+if __name__ == "__main__":
+    demo()