Add files using upload-large-folder tool

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

@@ -0,0 +1,102 @@
+# Natural Language Toolkit: Parsers
+#
+# 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
+#
+
+"""
+NLTK Parsers
+
+Classes and interfaces for producing tree structures that represent
+the internal organization of a text.  This task is known as "parsing"
+the text, and the resulting tree structures are called the text's
+"parses".  Typically, the text is a single sentence, and the tree
+structure represents the syntactic structure of the sentence.
+However, parsers can also be used in other domains.  For example,
+parsers can be used to derive the morphological structure of the
+morphemes that make up a word, or to derive the discourse structure
+for a set of utterances.
+
+Sometimes, a single piece of text can be represented by more than one
+tree structure.  Texts represented by more than one tree structure are
+called "ambiguous" texts.  Note that there are actually two ways in
+which a text can be ambiguous:
+
+    - The text has multiple correct parses.
+    - There is not enough information to decide which of several
+      candidate parses is correct.
+
+However, the parser module does *not* distinguish these two types of
+ambiguity.
+
+The parser module defines ``ParserI``, a standard interface for parsing
+texts; and two simple implementations of that interface,
+``ShiftReduceParser`` and ``RecursiveDescentParser``.  It also contains
+three sub-modules for specialized kinds of parsing:
+
+  - ``nltk.parser.chart`` defines chart parsing, which uses dynamic
+    programming to efficiently parse texts.
+  - ``nltk.parser.probabilistic`` defines probabilistic parsing, which
+    associates a probability with each parse.
+"""
+
+from nltk.parse.api import ParserI
+from nltk.parse.bllip import BllipParser
+from nltk.parse.chart import (
+    BottomUpChartParser,
+    BottomUpLeftCornerChartParser,
+    ChartParser,
+    LeftCornerChartParser,
+    SteppingChartParser,
+    TopDownChartParser,
+)
+from nltk.parse.corenlp import CoreNLPDependencyParser, CoreNLPParser
+from nltk.parse.dependencygraph import DependencyGraph
+from nltk.parse.earleychart import (
+    EarleyChartParser,
+    FeatureEarleyChartParser,
+    FeatureIncrementalBottomUpChartParser,
+    FeatureIncrementalBottomUpLeftCornerChartParser,
+    FeatureIncrementalChartParser,
+    FeatureIncrementalTopDownChartParser,
+    IncrementalBottomUpChartParser,
+    IncrementalBottomUpLeftCornerChartParser,
+    IncrementalChartParser,
+    IncrementalLeftCornerChartParser,
+    IncrementalTopDownChartParser,
+)
+from nltk.parse.evaluate import DependencyEvaluator
+from nltk.parse.featurechart import (
+    FeatureBottomUpChartParser,
+    FeatureBottomUpLeftCornerChartParser,
+    FeatureChartParser,
+    FeatureTopDownChartParser,
+)
+from nltk.parse.malt import MaltParser
+from nltk.parse.nonprojectivedependencyparser import (
+    NaiveBayesDependencyScorer,
+    NonprojectiveDependencyParser,
+    ProbabilisticNonprojectiveParser,
+)
+from nltk.parse.pchart import (
+    BottomUpProbabilisticChartParser,
+    InsideChartParser,
+    LongestChartParser,
+    RandomChartParser,
+    UnsortedChartParser,
+)
+from nltk.parse.projectivedependencyparser import (
+    ProbabilisticProjectiveDependencyParser,
+    ProjectiveDependencyParser,
+)
+from nltk.parse.recursivedescent import (
+    RecursiveDescentParser,
+    SteppingRecursiveDescentParser,
+)
+from nltk.parse.shiftreduce import ShiftReduceParser, SteppingShiftReduceParser
+from nltk.parse.transitionparser import TransitionParser
+from nltk.parse.util import TestGrammar, extract_test_sentences, load_parser
+from nltk.parse.viterbi import ViterbiParser

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

@@ -0,0 +1,299 @@
+# Natural Language Toolkit: Interface to BLLIP Parser
+#
+# Author: David McClosky <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from nltk.parse.api import ParserI
+from nltk.tree import Tree
+
+"""
+Interface for parsing with BLLIP Parser. Requires the Python
+bllipparser module. BllipParser objects can be constructed with the
+``BllipParser.from_unified_model_dir`` class method or manually using the
+``BllipParser`` constructor. The former is generally easier if you have
+a BLLIP Parser unified model directory -- a basic model can be obtained
+from NLTK's downloader. More unified parsing models can be obtained with
+BLLIP Parser's ModelFetcher (run ``python -m bllipparser.ModelFetcher``
+or see docs for ``bllipparser.ModelFetcher.download_and_install_model``).
+
+Basic usage::
+
+    # download and install a basic unified parsing model (Wall Street Journal)
+    # sudo python -m nltk.downloader bllip_wsj_no_aux
+
+    >>> from nltk.data import find
+    >>> model_dir = find('models/bllip_wsj_no_aux').path
+    >>> bllip = BllipParser.from_unified_model_dir(model_dir)
+
+    # 1-best parsing
+    >>> sentence1 = 'British left waffles on Falklands .'.split()
+    >>> top_parse = bllip.parse_one(sentence1)
+    >>> print(top_parse)
+    (S1
+      (S
+        (NP (JJ British) (NN left))
+        (VP (VBZ waffles) (PP (IN on) (NP (NNP Falklands))))
+        (. .)))
+
+    # n-best parsing
+    >>> sentence2 = 'Time flies'.split()
+    >>> all_parses = bllip.parse_all(sentence2)
+    >>> print(len(all_parses))
+    50
+    >>> print(all_parses[0])
+    (S1 (S (NP (NNP Time)) (VP (VBZ flies))))
+
+    # incorporating external tagging constraints (None means unconstrained tag)
+    >>> constrained1 = bllip.tagged_parse([('Time', 'VB'), ('flies', 'NNS')])
+    >>> print(next(constrained1))
+    (S1 (NP (VB Time) (NNS flies)))
+    >>> constrained2 = bllip.tagged_parse([('Time', 'NN'), ('flies', None)])
+    >>> print(next(constrained2))
+    (S1 (NP (NN Time) (VBZ flies)))
+
+References
+----------
+
+- Charniak, Eugene. "A maximum-entropy-inspired parser." Proceedings of
+  the 1st North American chapter of the Association for Computational
+  Linguistics conference. Association for Computational Linguistics,
+  2000.
+
+- Charniak, Eugene, and Mark Johnson. "Coarse-to-fine n-best parsing
+  and MaxEnt discriminative reranking." Proceedings of the 43rd Annual
+  Meeting on Association for Computational Linguistics. Association
+  for Computational Linguistics, 2005.
+
+Known issues
+------------
+
+Note that BLLIP Parser is not currently threadsafe. Since this module
+uses a SWIG interface, it is potentially unsafe to create multiple
+``BllipParser`` objects in the same process. BLLIP Parser currently
+has issues with non-ASCII text and will raise an error if given any.
+
+See https://pypi.python.org/pypi/bllipparser/ for more information
+on BLLIP Parser's Python interface.
+"""
+
+__all__ = ["BllipParser"]
+
+# this block allows this module to be imported even if bllipparser isn't
+# available
+try:
+    from bllipparser import RerankingParser
+    from bllipparser.RerankingParser import get_unified_model_parameters
+
+    def _ensure_bllip_import_or_error():
+        pass
+
+except ImportError as ie:
+
+    def _ensure_bllip_import_or_error(ie=ie):
+        raise ImportError("Couldn't import bllipparser module: %s" % ie)
+
+
+def _ensure_ascii(words):
+    try:
+        for i, word in enumerate(words):
+            word.encode("ascii")
+    except UnicodeEncodeError as e:
+        raise ValueError(
+            f"Token {i} ({word!r}) is non-ASCII. BLLIP Parser "
+            "currently doesn't support non-ASCII inputs."
+        ) from e
+
+
+def _scored_parse_to_nltk_tree(scored_parse):
+    return Tree.fromstring(str(scored_parse.ptb_parse))
+
+
+class BllipParser(ParserI):
+    """
+    Interface for parsing with BLLIP Parser. BllipParser objects can be
+    constructed with the ``BllipParser.from_unified_model_dir`` class
+    method or manually using the ``BllipParser`` constructor.
+    """
+
+    def __init__(
+        self,
+        parser_model=None,
+        reranker_features=None,
+        reranker_weights=None,
+        parser_options=None,
+        reranker_options=None,
+    ):
+        """
+        Load a BLLIP Parser model from scratch. You'll typically want to
+        use the ``from_unified_model_dir()`` class method to construct
+        this object.
+
+        :param parser_model: Path to parser model directory
+        :type parser_model: str
+
+        :param reranker_features: Path the reranker model's features file
+        :type reranker_features: str
+
+        :param reranker_weights: Path the reranker model's weights file
+        :type reranker_weights: str
+
+        :param parser_options: optional dictionary of parser options, see
+            ``bllipparser.RerankingParser.RerankingParser.load_parser_options()``
+            for more information.
+        :type parser_options: dict(str)
+
+        :param reranker_options: optional
+            dictionary of reranker options, see
+            ``bllipparser.RerankingParser.RerankingParser.load_reranker_model()``
+            for more information.
+        :type reranker_options: dict(str)
+        """
+        _ensure_bllip_import_or_error()
+
+        parser_options = parser_options or {}
+        reranker_options = reranker_options or {}
+
+        self.rrp = RerankingParser()
+        self.rrp.load_parser_model(parser_model, **parser_options)
+        if reranker_features and reranker_weights:
+            self.rrp.load_reranker_model(
+                features_filename=reranker_features,
+                weights_filename=reranker_weights,
+                **reranker_options,
+            )
+
+    def parse(self, sentence):
+        """
+        Use BLLIP Parser to parse a sentence. Takes a sentence as a list
+        of words; it will be automatically tagged with this BLLIP Parser
+        instance's tagger.
+
+        :return: An iterator that generates parse trees for the sentence
+            from most likely to least likely.
+
+        :param sentence: The sentence to be parsed
+        :type sentence: list(str)
+        :rtype: iter(Tree)
+        """
+        _ensure_ascii(sentence)
+        nbest_list = self.rrp.parse(sentence)
+        for scored_parse in nbest_list:
+            yield _scored_parse_to_nltk_tree(scored_parse)
+
+    def tagged_parse(self, word_and_tag_pairs):
+        """
+        Use BLLIP to parse a sentence. Takes a sentence as a list of
+        (word, tag) tuples; the sentence must have already been tokenized
+        and tagged. BLLIP will attempt to use the tags provided but may
+        use others if it can't come up with a complete parse subject
+        to those constraints. You may also specify a tag as ``None``
+        to leave a token's tag unconstrained.
+
+        :return: An iterator that generates parse trees for the sentence
+            from most likely to least likely.
+
+        :param sentence: Input sentence to parse as (word, tag) pairs
+        :type sentence: list(tuple(str, str))
+        :rtype: iter(Tree)
+        """
+        words = []
+        tag_map = {}
+        for i, (word, tag) in enumerate(word_and_tag_pairs):
+            words.append(word)
+            if tag is not None:
+                tag_map[i] = tag
+
+        _ensure_ascii(words)
+        nbest_list = self.rrp.parse_tagged(words, tag_map)
+        for scored_parse in nbest_list:
+            yield _scored_parse_to_nltk_tree(scored_parse)
+
+    @classmethod
+    def from_unified_model_dir(
+        cls, model_dir, parser_options=None, reranker_options=None
+    ):
+        """
+        Create a ``BllipParser`` object from a unified parsing model
+        directory. Unified parsing model directories are a standardized
+        way of storing BLLIP parser and reranker models together on disk.
+        See ``bllipparser.RerankingParser.get_unified_model_parameters()``
+        for more information about unified model directories.
+
+        :return: A ``BllipParser`` object using the parser and reranker
+            models in the model directory.
+
+        :param model_dir: Path to the unified model directory.
+        :type model_dir: str
+        :param parser_options: optional dictionary of parser options, see
+            ``bllipparser.RerankingParser.RerankingParser.load_parser_options()``
+            for more information.
+        :type parser_options: dict(str)
+        :param reranker_options: optional dictionary of reranker options, see
+            ``bllipparser.RerankingParser.RerankingParser.load_reranker_model()``
+            for more information.
+        :type reranker_options: dict(str)
+        :rtype: BllipParser
+        """
+        (
+            parser_model_dir,
+            reranker_features_filename,
+            reranker_weights_filename,
+        ) = get_unified_model_parameters(model_dir)
+        return cls(
+            parser_model_dir,
+            reranker_features_filename,
+            reranker_weights_filename,
+            parser_options,
+            reranker_options,
+        )
+
+
+def demo():
+    """This assumes the Python module bllipparser is installed."""
+
+    # download and install a basic unified parsing model (Wall Street Journal)
+    # sudo python -m nltk.downloader bllip_wsj_no_aux
+
+    from nltk.data import find
+
+    model_dir = find("models/bllip_wsj_no_aux").path
+
+    print("Loading BLLIP Parsing models...")
+    # the easiest way to get started is to use a unified model
+    bllip = BllipParser.from_unified_model_dir(model_dir)
+    print("Done.")
+
+    sentence1 = "British left waffles on Falklands .".split()
+    sentence2 = "I saw the man with the telescope .".split()
+    # this sentence is known to fail under the WSJ parsing model
+    fail1 = "# ! ? : -".split()
+    for sentence in (sentence1, sentence2, fail1):
+        print("Sentence: %r" % " ".join(sentence))
+        try:
+            tree = next(bllip.parse(sentence))
+            print(tree)
+        except StopIteration:
+            print("(parse failed)")
+
+    # n-best parsing demo
+    for i, parse in enumerate(bllip.parse(sentence1)):
+        print("parse %d:\n%s" % (i, parse))
+
+    # using external POS tag constraints
+    print(
+        "forcing 'tree' to be 'NN':",
+        next(bllip.tagged_parse([("A", None), ("tree", "NN")])),
+    )
+    print(
+        "forcing 'A' to be 'DT' and 'tree' to be 'NNP':",
+        next(bllip.tagged_parse([("A", "DT"), ("tree", "NNP")])),
+    )
+    # constraints don't have to make sense... (though on more complicated
+    # sentences, they may cause the parse to fail)
+    print(
+        "forcing 'A' to be 'NNP':",
+        next(bllip.tagged_parse([("A", "NNP"), ("tree", None)])),
+    )

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

@@ -0,0 +1,1848 @@
+# Natural Language Toolkit: A Chart Parser
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]>
+#         Jean Mark Gawron <[email protected]>
+#         Peter Ljunglöf <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Data classes and parser implementations for "chart parsers", which
+use dynamic programming to efficiently parse a text.  A chart
+parser derives parse trees for a text by iteratively adding "edges"
+to a "chart."  Each edge represents a hypothesis about the tree
+structure for a subsequence of the text.  The chart is a
+"blackboard" for composing and combining these hypotheses.
+
+When a chart parser begins parsing a text, it creates a new (empty)
+chart, spanning the text.  It then incrementally adds new edges to the
+chart.  A set of "chart rules" specifies the conditions under which
+new edges should be added to the chart.  Once the chart reaches a
+stage where none of the chart rules adds any new edges, parsing is
+complete.
+
+Charts are encoded with the ``Chart`` class, and edges are encoded with
+the ``TreeEdge`` and ``LeafEdge`` classes.  The chart parser module
+defines three chart parsers:
+
+  - ``ChartParser`` is a simple and flexible chart parser.  Given a
+    set of chart rules, it will apply those rules to the chart until
+    no more edges are added.
+
+  - ``SteppingChartParser`` is a subclass of ``ChartParser`` that can
+    be used to step through the parsing process.
+"""
+
+import itertools
+import re
+import warnings
+from functools import total_ordering
+
+from nltk.grammar import PCFG, is_nonterminal, is_terminal
+from nltk.internals import raise_unorderable_types
+from nltk.parse.api import ParserI
+from nltk.tree import Tree
+from nltk.util import OrderedDict
+
+########################################################################
+##  Edges
+########################################################################
+
+
+@total_ordering
+class EdgeI:
+    """
+    A hypothesis about the structure of part of a sentence.
+    Each edge records the fact that a structure is (partially)
+    consistent with the sentence.  An edge contains:
+
+    - A span, indicating what part of the sentence is
+      consistent with the hypothesized structure.
+    - A left-hand side, specifying what kind of structure is
+      hypothesized.
+    - A right-hand side, specifying the contents of the
+      hypothesized structure.
+    - A dot position, indicating how much of the hypothesized
+      structure is consistent with the sentence.
+
+    Every edge is either complete or incomplete:
+
+    - An edge is complete if its structure is fully consistent
+      with the sentence.
+    - An edge is incomplete if its structure is partially
+      consistent with the sentence.  For every incomplete edge, the
+      span specifies a possible prefix for the edge's structure.
+
+    There are two kinds of edge:
+
+    - A ``TreeEdge`` records which trees have been found to
+      be (partially) consistent with the text.
+    - A ``LeafEdge`` records the tokens occurring in the text.
+
+    The ``EdgeI`` interface provides a common interface to both types
+    of edge, allowing chart parsers to treat them in a uniform manner.
+    """
+
+    def __init__(self):
+        if self.__class__ == EdgeI:
+            raise TypeError("Edge is an abstract interface")
+
+    # ////////////////////////////////////////////////////////////
+    # Span
+    # ////////////////////////////////////////////////////////////
+
+    def span(self):
+        """
+        Return a tuple ``(s, e)``, where ``tokens[s:e]`` is the
+        portion of the sentence that is consistent with this
+        edge's structure.
+
+        :rtype: tuple(int, int)
+        """
+        raise NotImplementedError()
+
+    def start(self):
+        """
+        Return the start index of this edge's span.
+
+        :rtype: int
+        """
+        raise NotImplementedError()
+
+    def end(self):
+        """
+        Return the end index of this edge's span.
+
+        :rtype: int
+        """
+        raise NotImplementedError()
+
+    def length(self):
+        """
+        Return the length of this edge's span.
+
+        :rtype: int
+        """
+        raise NotImplementedError()
+
+    # ////////////////////////////////////////////////////////////
+    # Left Hand Side
+    # ////////////////////////////////////////////////////////////
+
+    def lhs(self):
+        """
+        Return this edge's left-hand side, which specifies what kind
+        of structure is hypothesized by this edge.
+
+        :see: ``TreeEdge`` and ``LeafEdge`` for a description of
+            the left-hand side values for each edge type.
+        """
+        raise NotImplementedError()
+
+    # ////////////////////////////////////////////////////////////
+    # Right Hand Side
+    # ////////////////////////////////////////////////////////////
+
+    def rhs(self):
+        """
+        Return this edge's right-hand side, which specifies
+        the content of the structure hypothesized by this edge.
+
+        :see: ``TreeEdge`` and ``LeafEdge`` for a description of
+            the right-hand side values for each edge type.
+        """
+        raise NotImplementedError()
+
+    def dot(self):
+        """
+        Return this edge's dot position, which indicates how much of
+        the hypothesized structure is consistent with the
+        sentence.  In particular, ``self.rhs[:dot]`` is consistent
+        with ``tokens[self.start():self.end()]``.
+
+        :rtype: int
+        """
+        raise NotImplementedError()
+
+    def nextsym(self):
+        """
+        Return the element of this edge's right-hand side that
+        immediately follows its dot.
+
+        :rtype: Nonterminal or terminal or None
+        """
+        raise NotImplementedError()
+
+    def is_complete(self):
+        """
+        Return True if this edge's structure is fully consistent
+        with the text.
+
+        :rtype: bool
+        """
+        raise NotImplementedError()
+
+    def is_incomplete(self):
+        """
+        Return True if this edge's structure is partially consistent
+        with the text.
+
+        :rtype: bool
+        """
+        raise NotImplementedError()
+
+    # ////////////////////////////////////////////////////////////
+    # Comparisons & hashing
+    # ////////////////////////////////////////////////////////////
+
+    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, EdgeI):
+            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 TreeEdge(EdgeI):
+    """
+    An edge that records the fact that a tree is (partially)
+    consistent with the sentence.  A tree edge consists of:
+
+    - A span, indicating what part of the sentence is
+      consistent with the hypothesized tree.
+    - A left-hand side, specifying the hypothesized tree's node
+      value.
+    - A right-hand side, specifying the hypothesized tree's
+      children.  Each element of the right-hand side is either a
+      terminal, specifying a token with that terminal as its leaf
+      value; or a nonterminal, specifying a subtree with that
+      nonterminal's symbol as its node value.
+    - A dot position, indicating which children are consistent
+      with part of the sentence.  In particular, if ``dot`` is the
+      dot position, ``rhs`` is the right-hand size, ``(start,end)``
+      is the span, and ``sentence`` is the list of tokens in the
+      sentence, then ``tokens[start:end]`` can be spanned by the
+      children specified by ``rhs[:dot]``.
+
+    For more information about edges, see the ``EdgeI`` interface.
+    """
+
+    def __init__(self, span, lhs, rhs, dot=0):
+        """
+        Construct a new ``TreeEdge``.
+
+        :type span: tuple(int, int)
+        :param span: A tuple ``(s, e)``, where ``tokens[s:e]`` is the
+            portion of the sentence that is consistent with the new
+            edge's structure.
+        :type lhs: Nonterminal
+        :param lhs: The new edge's left-hand side, specifying the
+            hypothesized tree's node value.
+        :type rhs: list(Nonterminal and str)
+        :param rhs: The new edge's right-hand side, specifying the
+            hypothesized tree's children.
+        :type dot: int
+        :param dot: The position of the new edge's dot.  This position
+            specifies what prefix of the production's right hand side
+            is consistent with the text.  In particular, if
+            ``sentence`` is the list of tokens in the sentence, then
+            ``okens[span[0]:span[1]]`` can be spanned by the
+            children specified by ``rhs[:dot]``.
+        """
+        self._span = span
+        self._lhs = lhs
+        rhs = tuple(rhs)
+        self._rhs = rhs
+        self._dot = dot
+        self._comparison_key = (span, lhs, rhs, dot)
+
+    @staticmethod
+    def from_production(production, index):
+        """
+        Return a new ``TreeEdge`` formed from the given production.
+        The new edge's left-hand side and right-hand side will
+        be taken from ``production``; its span will be
+        ``(index,index)``; and its dot position will be ``0``.
+
+        :rtype: TreeEdge
+        """
+        return TreeEdge(
+            span=(index, index), lhs=production.lhs(), rhs=production.rhs(), dot=0
+        )
+
+    def move_dot_forward(self, new_end):
+        """
+        Return a new ``TreeEdge`` formed from this edge.
+        The new edge's dot position is increased by ``1``,
+        and its end index will be replaced by ``new_end``.
+
+        :param new_end: The new end index.
+        :type new_end: int
+        :rtype: TreeEdge
+        """
+        return TreeEdge(
+            span=(self._span[0], new_end),
+            lhs=self._lhs,
+            rhs=self._rhs,
+            dot=self._dot + 1,
+        )
+
+    # Accessors
+    def lhs(self):
+        return self._lhs
+
+    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 self._rhs
+
+    def dot(self):
+        return self._dot
+
+    def is_complete(self):
+        return self._dot == len(self._rhs)
+
+    def is_incomplete(self):
+        return self._dot != len(self._rhs)
+
+    def nextsym(self):
+        if self._dot >= len(self._rhs):
+            return None
+        else:
+            return self._rhs[self._dot]
+
+    # String representation
+    def __str__(self):
+        str = f"[{self._span[0]}:{self._span[1]}] "
+        str += "%-2r ->" % (self._lhs,)
+
+        for i in range(len(self._rhs)):
+            if i == self._dot:
+                str += " *"
+            str += " %s" % repr(self._rhs[i])
+        if len(self._rhs) == self._dot:
+            str += " *"
+        return str
+
+    def __repr__(self):
+        return "[Edge: %s]" % self
+
+
+class LeafEdge(EdgeI):
+    """
+    An edge that records the fact that a leaf value is consistent with
+    a word in the sentence.  A leaf edge consists of:
+
+    - An index, indicating the position of the word.
+    - A leaf, specifying the word's content.
+
+    A leaf edge's left-hand side is its leaf value, and its right hand
+    side is ``()``.  Its span is ``[index, index+1]``, and its dot
+    position is ``0``.
+    """
+
+    def __init__(self, leaf, index):
+        """
+        Construct a new ``LeafEdge``.
+
+        :param leaf: The new edge's leaf value, specifying the word
+            that is recorded by this edge.
+        :param index: The new edge's index, specifying the position of
+            the word that is recorded by this edge.
+        """
+        self._leaf = leaf
+        self._index = index
+        self._comparison_key = (leaf, index)
+
+    # Accessors
+    def lhs(self):
+        return self._leaf
+
+    def span(self):
+        return (self._index, self._index + 1)
+
+    def start(self):
+        return self._index
+
+    def end(self):
+        return self._index + 1
+
+    def length(self):
+        return 1
+
+    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
+
+    # String representations
+    def __str__(self):
+        return f"[{self._index}:{self._index + 1}] {repr(self._leaf)}"
+
+    def __repr__(self):
+        return "[Edge: %s]" % (self)
+
+
+########################################################################
+##  Chart
+########################################################################
+
+
+class Chart:
+    """
+    A blackboard for hypotheses about the syntactic constituents of a
+    sentence.  A chart contains a set of edges, and each edge encodes
+    a single hypothesis about the structure of some portion of the
+    sentence.
+
+    The ``select`` method can be used to select a specific collection
+    of edges.  For example ``chart.select(is_complete=True, start=0)``
+    yields all complete edges whose start indices are 0.  To ensure
+    the efficiency of these selection operations, ``Chart`` dynamically
+    creates and maintains an index for each set of attributes that
+    have been selected on.
+
+    In order to reconstruct the trees that are represented by an edge,
+    the chart associates each edge with a set of child pointer lists.
+    A child pointer list is a list of the edges that license an
+    edge's right-hand side.
+
+    :ivar _tokens: The sentence that the chart covers.
+    :ivar _num_leaves: The number of tokens.
+    :ivar _edges: A list of the edges in the chart
+    :ivar _edge_to_cpls: A dictionary mapping each edge to a set
+        of child pointer lists that are associated with that edge.
+    :ivar _indexes: A dictionary mapping tuples of edge attributes
+        to indices, where each index maps the corresponding edge
+        attribute values to lists of edges.
+    """
+
+    def __init__(self, tokens):
+        """
+        Construct a new chart. The chart is initialized with the
+        leaf edges corresponding to the terminal leaves.
+
+        :type tokens: list
+        :param tokens: The sentence that this chart will be used to parse.
+        """
+        # Record the sentence token and the sentence length.
+        self._tokens = tuple(tokens)
+        self._num_leaves = len(self._tokens)
+
+        # Initialise the chart.
+        self.initialize()
+
+    def initialize(self):
+        """
+        Clear the chart.
+        """
+        # A list of edges contained in this chart.
+        self._edges = []
+
+        # The set of child pointer lists associated with each edge.
+        self._edge_to_cpls = {}
+
+        # Indexes mapping attribute values to lists of edges
+        # (used by select()).
+        self._indexes = {}
+
+    # ////////////////////////////////////////////////////////////
+    # Sentence Access
+    # ////////////////////////////////////////////////////////////
+
+    def num_leaves(self):
+        """
+        Return the number of words in this chart's sentence.
+
+        :rtype: int
+        """
+        return self._num_leaves
+
+    def leaf(self, index):
+        """
+        Return the leaf value of the word at the given index.
+
+        :rtype: str
+        """
+        return self._tokens[index]
+
+    def leaves(self):
+        """
+        Return a list of the leaf values of each word in the
+        chart's sentence.
+
+        :rtype: list(str)
+        """
+        return self._tokens
+
+    # ////////////////////////////////////////////////////////////
+    # Edge access
+    # ////////////////////////////////////////////////////////////
+
+    def edges(self):
+        """
+        Return a list of all edges in this chart.  New edges
+        that are added to the chart after the call to edges()
+        will *not* be contained in this list.
+
+        :rtype: list(EdgeI)
+        :see: ``iteredges``, ``select``
+        """
+        return self._edges[:]
+
+    def iteredges(self):
+        """
+        Return an iterator over the edges in this chart.  It is
+        not guaranteed that new edges which are added to the
+        chart before the iterator is exhausted will also be generated.
+
+        :rtype: iter(EdgeI)
+        :see: ``edges``, ``select``
+        """
+        return iter(self._edges)
+
+    # Iterating over the chart yields its edges.
+    __iter__ = iteredges
+
+    def num_edges(self):
+        """
+        Return the number of edges contained in this chart.
+
+        :rtype: int
+        """
+        return len(self._edge_to_cpls)
+
+    def select(self, **restrictions):
+        """
+        Return an iterator over the edges in this chart.  Any
+        new edges that are added to the chart before the iterator
+        is exahusted will also be generated.  ``restrictions``
+        can be used to restrict the set of edges that will be
+        generated.
+
+        :param span: Only generate edges ``e`` where ``e.span()==span``
+        :param start: Only generate edges ``e`` where ``e.start()==start``
+        :param end: Only generate edges ``e`` where ``e.end()==end``
+        :param length: Only generate edges ``e`` where ``e.length()==length``
+        :param lhs: Only generate edges ``e`` where ``e.lhs()==lhs``
+        :param rhs: Only generate edges ``e`` where ``e.rhs()==rhs``
+        :param nextsym: Only generate edges ``e`` where
+            ``e.nextsym()==nextsym``
+        :param dot: Only generate edges ``e`` where ``e.dot()==dot``
+        :param is_complete: Only generate edges ``e`` where
+            ``e.is_complete()==is_complete``
+        :param is_incomplete: Only generate edges ``e`` where
+            ``e.is_incomplete()==is_incomplete``
+        :rtype: iter(EdgeI)
+        """
+        # If there are no restrictions, then return all edges.
+        if restrictions == {}:
+            return iter(self._edges)
+
+        # Find the index corresponding to the given restrictions.
+        restr_keys = sorted(restrictions.keys())
+        restr_keys = tuple(restr_keys)
+
+        # If it doesn't exist, then create it.
+        if restr_keys not in self._indexes:
+            self._add_index(restr_keys)
+
+        vals = tuple(restrictions[key] for key in restr_keys)
+        return iter(self._indexes[restr_keys].get(vals, []))
+
+    def _add_index(self, restr_keys):
+        """
+        A helper function for ``select``, which creates a new index for
+        a given set of attributes (aka restriction keys).
+        """
+        # Make sure it's a valid index.
+        for key in restr_keys:
+            if not hasattr(EdgeI, key):
+                raise ValueError("Bad restriction: %s" % key)
+
+        # Create the index.
+        index = self._indexes[restr_keys] = {}
+
+        # Add all existing edges to the index.
+        for edge in self._edges:
+            vals = tuple(getattr(edge, key)() for key in restr_keys)
+            index.setdefault(vals, []).append(edge)
+
+    def _register_with_indexes(self, edge):
+        """
+        A helper function for ``insert``, which registers the new
+        edge with all existing indexes.
+        """
+        for (restr_keys, index) in self._indexes.items():
+            vals = tuple(getattr(edge, key)() for key in restr_keys)
+            index.setdefault(vals, []).append(edge)
+
+    # ////////////////////////////////////////////////////////////
+    # Edge Insertion
+    # ////////////////////////////////////////////////////////////
+
+    def insert_with_backpointer(self, new_edge, previous_edge, child_edge):
+        """
+        Add a new edge to the chart, using a pointer to the previous edge.
+        """
+        cpls = self.child_pointer_lists(previous_edge)
+        new_cpls = [cpl + (child_edge,) for cpl in cpls]
+        return self.insert(new_edge, *new_cpls)
+
+    def insert(self, edge, *child_pointer_lists):
+        """
+        Add a new edge to the chart, and return True if this operation
+        modified the chart.  In particular, return true iff the chart
+        did not already contain ``edge``, or if it did not already associate
+        ``child_pointer_lists`` with ``edge``.
+
+        :type edge: EdgeI
+        :param edge: The new edge
+        :type child_pointer_lists: sequence of tuple(EdgeI)
+        :param child_pointer_lists: A sequence of lists of the edges that
+            were used to form this edge.  This list is used to reconstruct
+            the trees (or partial trees) that are associated with ``edge``.
+        :rtype: bool
+        """
+        # Is it a new edge?
+        if edge not in self._edge_to_cpls:
+            # Add it to the list of edges.
+            self._append_edge(edge)
+            # Register with indexes.
+            self._register_with_indexes(edge)
+
+        # Get the set of child pointer lists for this edge.
+        cpls = self._edge_to_cpls.setdefault(edge, OrderedDict())
+        chart_was_modified = False
+        for child_pointer_list in child_pointer_lists:
+            child_pointer_list = tuple(child_pointer_list)
+            if child_pointer_list not in cpls:
+                # It's a new CPL; register it, and return true.
+                cpls[child_pointer_list] = True
+                chart_was_modified = True
+        return chart_was_modified
+
+    def _append_edge(self, edge):
+        self._edges.append(edge)
+
+    # ////////////////////////////////////////////////////////////
+    # Tree extraction & child pointer lists
+    # ////////////////////////////////////////////////////////////
+
+    def parses(self, root, tree_class=Tree):
+        """
+        Return an iterator of the complete tree structures that span
+        the entire chart, and whose root node is ``root``.
+        """
+        for edge in self.select(start=0, end=self._num_leaves, lhs=root):
+            yield from self.trees(edge, tree_class=tree_class, complete=True)
+
+    def trees(self, edge, tree_class=Tree, complete=False):
+        """
+        Return an iterator of the tree structures that are associated
+        with ``edge``.
+
+        If ``edge`` is incomplete, then the unexpanded children will be
+        encoded as childless subtrees, whose node value is the
+        corresponding terminal or nonterminal.
+
+        :rtype: list(Tree)
+        :note: If two trees share a common subtree, then the same
+            Tree may be used to encode that subtree in
+            both trees.  If you need to eliminate this subtree
+            sharing, then create a deep copy of each tree.
+        """
+        return iter(self._trees(edge, complete, memo={}, tree_class=tree_class))
+
+    def _trees(self, edge, complete, memo, tree_class):
+        """
+        A helper function for ``trees``.
+
+        :param memo: A dictionary used to record the trees that we've
+            generated for each edge, so that when we see an edge more
+            than once, we can reuse the same trees.
+        """
+        # If we've seen this edge before, then reuse our old answer.
+        if edge in memo:
+            return memo[edge]
+
+        # when we're reading trees off the chart, don't use incomplete edges
+        if complete and edge.is_incomplete():
+            return []
+
+        # Leaf edges.
+        if isinstance(edge, LeafEdge):
+            leaf = self._tokens[edge.start()]
+            memo[edge] = [leaf]
+            return [leaf]
+
+        # Until we're done computing the trees for edge, set
+        # memo[edge] to be empty.  This has the effect of filtering
+        # out any cyclic trees (i.e., trees that contain themselves as
+        # descendants), because if we reach this edge via a cycle,
+        # then it will appear that the edge doesn't generate any trees.
+        memo[edge] = []
+        trees = []
+        lhs = edge.lhs().symbol()
+
+        # Each child pointer list can be used to form trees.
+        for cpl in self.child_pointer_lists(edge):
+            # Get the set of child choices for each child pointer.
+            # child_choices[i] is the set of choices for the tree's
+            # ith child.
+            child_choices = [self._trees(cp, complete, memo, tree_class) for cp in cpl]
+
+            # For each combination of children, add a tree.
+            for children in itertools.product(*child_choices):
+                trees.append(tree_class(lhs, children))
+
+        # If the edge is incomplete, then extend it with "partial trees":
+        if edge.is_incomplete():
+            unexpanded = [tree_class(elt, []) for elt in edge.rhs()[edge.dot() :]]
+            for tree in trees:
+                tree.extend(unexpanded)
+
+        # Update the memoization dictionary.
+        memo[edge] = trees
+
+        # Return the list of trees.
+        return trees
+
+    def child_pointer_lists(self, edge):
+        """
+        Return the set of child pointer lists for the given edge.
+        Each child pointer list is a list of edges that have
+        been used to form this edge.
+
+        :rtype: list(list(EdgeI))
+        """
+        # Make a copy, in case they modify it.
+        return self._edge_to_cpls.get(edge, {}).keys()
+
+    # ////////////////////////////////////////////////////////////
+    # Display
+    # ////////////////////////////////////////////////////////////
+    def pretty_format_edge(self, edge, width=None):
+        """
+        Return a pretty-printed string representation of a given edge
+        in this chart.
+
+        :rtype: str
+        :param width: The number of characters allotted to each
+            index in the sentence.
+        """
+        if width is None:
+            width = 50 // (self.num_leaves() + 1)
+        (start, end) = (edge.start(), edge.end())
+
+        str = "|" + ("." + " " * (width - 1)) * start
+
+        # Zero-width edges are "#" if complete, ">" if incomplete
+        if start == end:
+            if edge.is_complete():
+                str += "#"
+            else:
+                str += ">"
+
+        # Spanning complete edges are "[===]"; Other edges are
+        # "[---]" if complete, "[--->" if incomplete
+        elif edge.is_complete() and edge.span() == (0, self._num_leaves):
+            str += "[" + ("=" * width) * (end - start - 1) + "=" * (width - 1) + "]"
+        elif edge.is_complete():
+            str += "[" + ("-" * width) * (end - start - 1) + "-" * (width - 1) + "]"
+        else:
+            str += "[" + ("-" * width) * (end - start - 1) + "-" * (width - 1) + ">"
+
+        str += (" " * (width - 1) + ".") * (self._num_leaves - end)
+        return str + "| %s" % edge
+
+    def pretty_format_leaves(self, width=None):
+        """
+        Return a pretty-printed string representation of this
+        chart's leaves.  This string can be used as a header
+        for calls to ``pretty_format_edge``.
+        """
+        if width is None:
+            width = 50 // (self.num_leaves() + 1)
+
+        if self._tokens is not None and width > 1:
+            header = "|."
+            for tok in self._tokens:
+                header += tok[: width - 1].center(width - 1) + "."
+            header += "|"
+        else:
+            header = ""
+
+        return header
+
+    def pretty_format(self, width=None):
+        """
+        Return a pretty-printed string representation of this chart.
+
+        :param width: The number of characters allotted to each
+            index in the sentence.
+        :rtype: str
+        """
+        if width is None:
+            width = 50 // (self.num_leaves() + 1)
+        # sort edges: primary key=length, secondary key=start index.
+        # (and filter out the token edges)
+        edges = sorted((e.length(), e.start(), e) for e in self)
+        edges = [e for (_, _, e) in edges]
+
+        return (
+            self.pretty_format_leaves(width)
+            + "\n"
+            + "\n".join(self.pretty_format_edge(edge, width) for edge in edges)
+        )
+
+    # ////////////////////////////////////////////////////////////
+    # Display: Dot (AT&T Graphviz)
+    # ////////////////////////////////////////////////////////////
+
+    def dot_digraph(self):
+        # Header
+        s = "digraph nltk_chart {\n"
+        # s += '  size="5,5";\n'
+        s += "  rankdir=LR;\n"
+        s += "  node [height=0.1,width=0.1];\n"
+        s += '  node [style=filled, color="lightgray"];\n'
+
+        # Set up the nodes
+        for y in range(self.num_edges(), -1, -1):
+            if y == 0:
+                s += '  node [style=filled, color="black"];\n'
+            for x in range(self.num_leaves() + 1):
+                if y == 0 or (
+                    x <= self._edges[y - 1].start() or x >= self._edges[y - 1].end()
+                ):
+                    s += '  %04d.%04d [label=""];\n' % (x, y)
+
+        # Add a spacer
+        s += "  x [style=invis]; x->0000.0000 [style=invis];\n"
+
+        # Declare ranks.
+        for x in range(self.num_leaves() + 1):
+            s += "  {rank=same;"
+            for y in range(self.num_edges() + 1):
+                if y == 0 or (
+                    x <= self._edges[y - 1].start() or x >= self._edges[y - 1].end()
+                ):
+                    s += " %04d.%04d" % (x, y)
+            s += "}\n"
+
+        # Add the leaves
+        s += "  edge [style=invis, weight=100];\n"
+        s += "  node [shape=plaintext]\n"
+        s += "  0000.0000"
+        for x in range(self.num_leaves()):
+            s += "->%s->%04d.0000" % (self.leaf(x), x + 1)
+        s += ";\n\n"
+
+        # Add the edges
+        s += "  edge [style=solid, weight=1];\n"
+        for y, edge in enumerate(self):
+            for x in range(edge.start()):
+                s += '  %04d.%04d -> %04d.%04d [style="invis"];\n' % (
+                    x,
+                    y + 1,
+                    x + 1,
+                    y + 1,
+                )
+            s += '  %04d.%04d -> %04d.%04d [label="%s"];\n' % (
+                edge.start(),
+                y + 1,
+                edge.end(),
+                y + 1,
+                edge,
+            )
+            for x in range(edge.end(), self.num_leaves()):
+                s += '  %04d.%04d -> %04d.%04d [style="invis"];\n' % (
+                    x,
+                    y + 1,
+                    x + 1,
+                    y + 1,
+                )
+        s += "}\n"
+        return s
+
+
+########################################################################
+##  Chart Rules
+########################################################################
+
+
+class ChartRuleI:
+    """
+    A rule that specifies what new edges are licensed by any given set
+    of existing edges.  Each chart rule expects a fixed number of
+    edges, as indicated by the class variable ``NUM_EDGES``.  In
+    particular:
+
+    - A chart rule with ``NUM_EDGES=0`` specifies what new edges are
+      licensed, regardless of existing edges.
+    - A chart rule with ``NUM_EDGES=1`` specifies what new edges are
+      licensed by a single existing edge.
+    - A chart rule with ``NUM_EDGES=2`` specifies what new edges are
+      licensed by a pair of existing edges.
+
+    :type NUM_EDGES: int
+    :cvar NUM_EDGES: The number of existing edges that this rule uses
+        to license new edges.  Typically, this number ranges from zero
+        to two.
+    """
+
+    def apply(self, chart, grammar, *edges):
+        """
+        Return a generator that will add edges licensed by this rule
+        and the given edges to the chart, one at a time.  Each
+        time the generator is resumed, it will either add a new
+        edge and yield that edge; or return.
+
+        :type edges: list(EdgeI)
+        :param edges: A set of existing edges.  The number of edges
+            that should be passed to ``apply()`` is specified by the
+            ``NUM_EDGES`` class variable.
+        :rtype: iter(EdgeI)
+        """
+        raise NotImplementedError()
+
+    def apply_everywhere(self, chart, grammar):
+        """
+        Return a generator that will add all edges licensed by
+        this rule, given the edges that are currently in the
+        chart, one at a time.  Each time the generator is resumed,
+        it will either add a new edge and yield that edge; or return.
+
+        :rtype: iter(EdgeI)
+        """
+        raise NotImplementedError()
+
+
+class AbstractChartRule(ChartRuleI):
+    """
+    An abstract base class for chart rules.  ``AbstractChartRule``
+    provides:
+
+    - A default implementation for ``apply``.
+    - A default implementation for ``apply_everywhere``,
+      (Currently, this implementation assumes that ``NUM_EDGES <= 3``.)
+    - A default implementation for ``__str__``, which returns a
+      name based on the rule's class name.
+    """
+
+    # Subclasses must define apply.
+    def apply(self, chart, grammar, *edges):
+        raise NotImplementedError()
+
+    # Default: loop through the given number of edges, and call
+    # self.apply() for each set of edges.
+    def apply_everywhere(self, chart, grammar):
+        if self.NUM_EDGES == 0:
+            yield from self.apply(chart, grammar)
+
+        elif self.NUM_EDGES == 1:
+            for e1 in chart:
+                yield from self.apply(chart, grammar, e1)
+
+        elif self.NUM_EDGES == 2:
+            for e1 in chart:
+                for e2 in chart:
+                    yield from self.apply(chart, grammar, e1, e2)
+
+        elif self.NUM_EDGES == 3:
+            for e1 in chart:
+                for e2 in chart:
+                    for e3 in chart:
+                        yield from self.apply(chart, grammar, e1, e2, e3)
+
+        else:
+            raise AssertionError("NUM_EDGES>3 is not currently supported")
+
+    # Default: return a name based on the class name.
+    def __str__(self):
+        # Add spaces between InitialCapsWords.
+        return re.sub("([a-z])([A-Z])", r"\1 \2", self.__class__.__name__)
+
+
+# ////////////////////////////////////////////////////////////
+# Fundamental Rule
+# ////////////////////////////////////////////////////////////
+
+
+class FundamentalRule(AbstractChartRule):
+    r"""
+    A rule that joins two adjacent edges to form a single combined
+    edge.  In particular, this rule specifies that any pair of edges
+
+    - ``[A -> alpha \* B beta][i:j]``
+    - ``[B -> gamma \*][j:k]``
+
+    licenses the edge:
+
+    - ``[A -> alpha B * beta][i:j]``
+    """
+
+    NUM_EDGES = 2
+
+    def apply(self, chart, grammar, left_edge, right_edge):
+        # Make sure the rule is applicable.
+        if not (
+            left_edge.is_incomplete()
+            and right_edge.is_complete()
+            and left_edge.end() == right_edge.start()
+            and left_edge.nextsym() == right_edge.lhs()
+        ):
+            return
+
+        # Construct the new edge.
+        new_edge = left_edge.move_dot_forward(right_edge.end())
+
+        # Insert it into the chart.
+        if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+            yield new_edge
+
+
+class SingleEdgeFundamentalRule(FundamentalRule):
+    r"""
+    A rule that joins a given edge with adjacent edges in the chart,
+    to form combined edges.  In particular, this rule specifies that
+    either of the edges:
+
+    - ``[A -> alpha \* B beta][i:j]``
+    - ``[B -> gamma \*][j:k]``
+
+    licenses the edge:
+
+    - ``[A -> alpha B * beta][i:j]``
+
+    if the other edge is already in the chart.
+
+    :note: This is basically ``FundamentalRule``, with one edge left
+        unspecified.
+    """
+
+    NUM_EDGES = 1
+
+    def apply(self, chart, grammar, edge):
+        if edge.is_incomplete():
+            yield from self._apply_incomplete(chart, grammar, edge)
+        else:
+            yield from self._apply_complete(chart, grammar, edge)
+
+    def _apply_complete(self, chart, grammar, right_edge):
+        for left_edge in chart.select(
+            end=right_edge.start(), is_complete=False, nextsym=right_edge.lhs()
+        ):
+            new_edge = left_edge.move_dot_forward(right_edge.end())
+            if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+                yield new_edge
+
+    def _apply_incomplete(self, chart, grammar, left_edge):
+        for right_edge in chart.select(
+            start=left_edge.end(), is_complete=True, lhs=left_edge.nextsym()
+        ):
+            new_edge = left_edge.move_dot_forward(right_edge.end())
+            if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+                yield new_edge
+
+
+# ////////////////////////////////////////////////////////////
+# Inserting Terminal Leafs
+# ////////////////////////////////////////////////////////////
+
+
+class LeafInitRule(AbstractChartRule):
+    NUM_EDGES = 0
+
+    def apply(self, chart, grammar):
+        for index in range(chart.num_leaves()):
+            new_edge = LeafEdge(chart.leaf(index), index)
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+
+# ////////////////////////////////////////////////////////////
+# Top-Down Prediction
+# ////////////////////////////////////////////////////////////
+
+
+class TopDownInitRule(AbstractChartRule):
+    r"""
+    A rule licensing edges corresponding to the grammar productions for
+    the grammar's start symbol.  In particular, this rule specifies that
+    ``[S -> \* alpha][0:i]`` is licensed for each grammar production
+    ``S -> alpha``, where ``S`` is the grammar's start symbol.
+    """
+
+    NUM_EDGES = 0
+
+    def apply(self, chart, grammar):
+        for prod in grammar.productions(lhs=grammar.start()):
+            new_edge = TreeEdge.from_production(prod, 0)
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+
+class TopDownPredictRule(AbstractChartRule):
+    r"""
+    A rule licensing edges corresponding to the grammar productions
+    for the nonterminal following an incomplete edge's dot.  In
+    particular, this rule specifies that
+    ``[A -> alpha \* B beta][i:j]`` licenses the edge
+    ``[B -> \* gamma][j:j]`` for each grammar production ``B -> gamma``.
+
+    :note: This rule corresponds to the Predictor Rule in Earley parsing.
+    """
+
+    NUM_EDGES = 1
+
+    def apply(self, chart, grammar, edge):
+        if edge.is_complete():
+            return
+        for prod in grammar.productions(lhs=edge.nextsym()):
+            new_edge = TreeEdge.from_production(prod, edge.end())
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+
+class CachedTopDownPredictRule(TopDownPredictRule):
+    r"""
+    A cached version of ``TopDownPredictRule``.  After the first time
+    this rule is applied to an edge with a given ``end`` and ``next``,
+    it will not generate any more edges for edges with that ``end`` and
+    ``next``.
+
+    If ``chart`` or ``grammar`` are changed, then the cache is flushed.
+    """
+
+    def __init__(self):
+        TopDownPredictRule.__init__(self)
+        self._done = {}
+
+    def apply(self, chart, grammar, edge):
+        if edge.is_complete():
+            return
+        nextsym, index = edge.nextsym(), edge.end()
+        if not is_nonterminal(nextsym):
+            return
+
+        # If we've already applied this rule to an edge with the same
+        # next & end, and the chart & grammar have not changed, then
+        # just return (no new edges to add).
+        done = self._done.get((nextsym, index), (None, None))
+        if done[0] is chart and done[1] is grammar:
+            return
+
+        # Add all the edges indicated by the top down expand rule.
+        for prod in grammar.productions(lhs=nextsym):
+            # If the left corner in the predicted production is
+            # leaf, it must match with the input.
+            if prod.rhs():
+                first = prod.rhs()[0]
+                if is_terminal(first):
+                    if index >= chart.num_leaves() or first != chart.leaf(index):
+                        continue
+
+            new_edge = TreeEdge.from_production(prod, index)
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+        # Record the fact that we've applied this rule.
+        self._done[nextsym, index] = (chart, grammar)
+
+
+# ////////////////////////////////////////////////////////////
+# Bottom-Up Prediction
+# ////////////////////////////////////////////////////////////
+
+
+class BottomUpPredictRule(AbstractChartRule):
+    r"""
+    A rule licensing any edge corresponding to a production whose
+    right-hand side begins with a complete edge's left-hand side.  In
+    particular, this rule specifies that ``[A -> alpha \*]`` licenses
+    the edge ``[B -> \* A beta]`` for each grammar production ``B -> A beta``.
+    """
+
+    NUM_EDGES = 1
+
+    def apply(self, chart, grammar, edge):
+        if edge.is_incomplete():
+            return
+        for prod in grammar.productions(rhs=edge.lhs()):
+            new_edge = TreeEdge.from_production(prod, edge.start())
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+
+class BottomUpPredictCombineRule(BottomUpPredictRule):
+    r"""
+    A rule licensing any edge corresponding to a production whose
+    right-hand side begins with a complete edge's left-hand side.  In
+    particular, this rule specifies that ``[A -> alpha \*]``
+    licenses the edge ``[B -> A \* beta]`` for each grammar
+    production ``B -> A beta``.
+
+    :note: This is like ``BottomUpPredictRule``, but it also applies
+        the ``FundamentalRule`` to the resulting edge.
+    """
+
+    NUM_EDGES = 1
+
+    def apply(self, chart, grammar, edge):
+        if edge.is_incomplete():
+            return
+        for prod in grammar.productions(rhs=edge.lhs()):
+            new_edge = TreeEdge(edge.span(), prod.lhs(), prod.rhs(), 1)
+            if chart.insert(new_edge, (edge,)):
+                yield new_edge
+
+
+class EmptyPredictRule(AbstractChartRule):
+    """
+    A rule that inserts all empty productions as passive edges,
+    in every position in the chart.
+    """
+
+    NUM_EDGES = 0
+
+    def apply(self, chart, grammar):
+        for prod in grammar.productions(empty=True):
+            for index in range(chart.num_leaves() + 1):
+                new_edge = TreeEdge.from_production(prod, index)
+                if chart.insert(new_edge, ()):
+                    yield new_edge
+
+
+########################################################################
+##  Filtered Bottom Up
+########################################################################
+
+
+class FilteredSingleEdgeFundamentalRule(SingleEdgeFundamentalRule):
+    def _apply_complete(self, chart, grammar, right_edge):
+        end = right_edge.end()
+        nexttoken = end < chart.num_leaves() and chart.leaf(end)
+        for left_edge in chart.select(
+            end=right_edge.start(), is_complete=False, nextsym=right_edge.lhs()
+        ):
+            if _bottomup_filter(grammar, nexttoken, left_edge.rhs(), left_edge.dot()):
+                new_edge = left_edge.move_dot_forward(right_edge.end())
+                if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+                    yield new_edge
+
+    def _apply_incomplete(self, chart, grammar, left_edge):
+        for right_edge in chart.select(
+            start=left_edge.end(), is_complete=True, lhs=left_edge.nextsym()
+        ):
+            end = right_edge.end()
+            nexttoken = end < chart.num_leaves() and chart.leaf(end)
+            if _bottomup_filter(grammar, nexttoken, left_edge.rhs(), left_edge.dot()):
+                new_edge = left_edge.move_dot_forward(right_edge.end())
+                if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+                    yield new_edge
+
+
+class FilteredBottomUpPredictCombineRule(BottomUpPredictCombineRule):
+    def apply(self, chart, grammar, edge):
+        if edge.is_incomplete():
+            return
+
+        end = edge.end()
+        nexttoken = end < chart.num_leaves() and chart.leaf(end)
+        for prod in grammar.productions(rhs=edge.lhs()):
+            if _bottomup_filter(grammar, nexttoken, prod.rhs()):
+                new_edge = TreeEdge(edge.span(), prod.lhs(), prod.rhs(), 1)
+                if chart.insert(new_edge, (edge,)):
+                    yield new_edge
+
+
+def _bottomup_filter(grammar, nexttoken, rhs, dot=0):
+    if len(rhs) <= dot + 1:
+        return True
+    _next = rhs[dot + 1]
+    if is_terminal(_next):
+        return nexttoken == _next
+    else:
+        return grammar.is_leftcorner(_next, nexttoken)
+
+
+########################################################################
+##  Generic Chart Parser
+########################################################################
+
+TD_STRATEGY = [
+    LeafInitRule(),
+    TopDownInitRule(),
+    CachedTopDownPredictRule(),
+    SingleEdgeFundamentalRule(),
+]
+BU_STRATEGY = [
+    LeafInitRule(),
+    EmptyPredictRule(),
+    BottomUpPredictRule(),
+    SingleEdgeFundamentalRule(),
+]
+BU_LC_STRATEGY = [
+    LeafInitRule(),
+    EmptyPredictRule(),
+    BottomUpPredictCombineRule(),
+    SingleEdgeFundamentalRule(),
+]
+
+LC_STRATEGY = [
+    LeafInitRule(),
+    FilteredBottomUpPredictCombineRule(),
+    FilteredSingleEdgeFundamentalRule(),
+]
+
+
+class ChartParser(ParserI):
+    """
+    A generic chart parser.  A "strategy", or list of
+    ``ChartRuleI`` instances, is used to decide what edges to add to
+    the chart.  In particular, ``ChartParser`` uses the following
+    algorithm to parse texts:
+
+    | Until no new edges are added:
+    |   For each *rule* in *strategy*:
+    |     Apply *rule* to any applicable edges in the chart.
+    | Return any complete parses in the chart
+    """
+
+    def __init__(
+        self,
+        grammar,
+        strategy=BU_LC_STRATEGY,
+        trace=0,
+        trace_chart_width=50,
+        use_agenda=True,
+        chart_class=Chart,
+    ):
+        """
+        Create a new chart parser, that uses ``grammar`` to parse
+        texts.
+
+        :type grammar: CFG
+        :param grammar: The grammar used to parse texts.
+        :type strategy: list(ChartRuleI)
+        :param strategy: A list of rules that should be used to decide
+            what edges to add to the chart (top-down strategy by default).
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            and higher numbers will produce more verbose tracing
+            output.
+        :type trace_chart_width: int
+        :param trace_chart_width: The default total width reserved for
+            the chart in trace output.  The remainder of each line will
+            be used to display edges.
+        :type use_agenda: bool
+        :param use_agenda: Use an optimized agenda-based algorithm,
+            if possible.
+        :param chart_class: The class that should be used to create
+            the parse charts.
+        """
+        self._grammar = grammar
+        self._strategy = strategy
+        self._trace = trace
+        self._trace_chart_width = trace_chart_width
+        # If the strategy only consists of axioms (NUM_EDGES==0) and
+        # inference rules (NUM_EDGES==1), we can use an agenda-based algorithm:
+        self._use_agenda = use_agenda
+        self._chart_class = chart_class
+
+        self._axioms = []
+        self._inference_rules = []
+        for rule in strategy:
+            if rule.NUM_EDGES == 0:
+                self._axioms.append(rule)
+            elif rule.NUM_EDGES == 1:
+                self._inference_rules.append(rule)
+            else:
+                self._use_agenda = False
+
+    def grammar(self):
+        return self._grammar
+
+    def _trace_new_edges(self, chart, rule, new_edges, trace, edge_width):
+        if not trace:
+            return
+        print_rule_header = trace > 1
+        for edge in new_edges:
+            if print_rule_header:
+                print("%s:" % rule)
+                print_rule_header = False
+            print(chart.pretty_format_edge(edge, edge_width))
+
+    def chart_parse(self, tokens, trace=None):
+        """
+        Return the final parse ``Chart`` from which all possible
+        parse trees can be extracted.
+
+        :param tokens: The sentence to be parsed
+        :type tokens: list(str)
+        :rtype: Chart
+        """
+        if trace is None:
+            trace = self._trace
+        trace_new_edges = self._trace_new_edges
+
+        tokens = list(tokens)
+        self._grammar.check_coverage(tokens)
+        chart = self._chart_class(tokens)
+        grammar = self._grammar
+
+        # Width, for printing trace edges.
+        trace_edge_width = self._trace_chart_width // (chart.num_leaves() + 1)
+        if trace:
+            print(chart.pretty_format_leaves(trace_edge_width))
+
+        if self._use_agenda:
+            # Use an agenda-based algorithm.
+            for axiom in self._axioms:
+                new_edges = list(axiom.apply(chart, grammar))
+                trace_new_edges(chart, axiom, new_edges, trace, trace_edge_width)
+
+            inference_rules = self._inference_rules
+            agenda = chart.edges()
+            # We reverse the initial agenda, since it is a stack
+            # but chart.edges() functions as a queue.
+            agenda.reverse()
+            while agenda:
+                edge = agenda.pop()
+                for rule in inference_rules:
+                    new_edges = list(rule.apply(chart, grammar, edge))
+                    if trace:
+                        trace_new_edges(chart, rule, new_edges, trace, trace_edge_width)
+                    agenda += new_edges
+
+        else:
+            # Do not use an agenda-based algorithm.
+            edges_added = True
+            while edges_added:
+                edges_added = False
+                for rule in self._strategy:
+                    new_edges = list(rule.apply_everywhere(chart, grammar))
+                    edges_added = len(new_edges)
+                    trace_new_edges(chart, rule, new_edges, trace, trace_edge_width)
+
+        # Return the final chart.
+        return chart
+
+    def parse(self, tokens, tree_class=Tree):
+        chart = self.chart_parse(tokens)
+        return iter(chart.parses(self._grammar.start(), tree_class=tree_class))
+
+
+class TopDownChartParser(ChartParser):
+    """
+    A ``ChartParser`` using a top-down parsing strategy.
+    See ``ChartParser`` for more information.
+    """
+
+    def __init__(self, grammar, **parser_args):
+        ChartParser.__init__(self, grammar, TD_STRATEGY, **parser_args)
+
+
+class BottomUpChartParser(ChartParser):
+    """
+    A ``ChartParser`` using a bottom-up parsing strategy.
+    See ``ChartParser`` for more information.
+    """
+
+    def __init__(self, grammar, **parser_args):
+        if isinstance(grammar, PCFG):
+            warnings.warn(
+                "BottomUpChartParser only works for CFG, "
+                "use BottomUpProbabilisticChartParser instead",
+                category=DeprecationWarning,
+            )
+        ChartParser.__init__(self, grammar, BU_STRATEGY, **parser_args)
+
+
+class BottomUpLeftCornerChartParser(ChartParser):
+    """
+    A ``ChartParser`` using a bottom-up left-corner parsing strategy.
+    This strategy is often more efficient than standard bottom-up.
+    See ``ChartParser`` for more information.
+    """
+
+    def __init__(self, grammar, **parser_args):
+        ChartParser.__init__(self, grammar, BU_LC_STRATEGY, **parser_args)
+
+
+class LeftCornerChartParser(ChartParser):
+    def __init__(self, grammar, **parser_args):
+        if not grammar.is_nonempty():
+            raise ValueError(
+                "LeftCornerParser only works for grammars " "without empty productions."
+            )
+        ChartParser.__init__(self, grammar, LC_STRATEGY, **parser_args)
+
+
+########################################################################
+##  Stepping Chart Parser
+########################################################################
+
+
+class SteppingChartParser(ChartParser):
+    """
+    A ``ChartParser`` that allows you to step through the parsing
+    process, adding a single edge at a time.  It also allows you to
+    change the parser's strategy or grammar midway through parsing a
+    text.
+
+    The ``initialize`` method is used to start parsing a text.  ``step``
+    adds a single edge to the chart.  ``set_strategy`` changes the
+    strategy used by the chart parser.  ``parses`` returns the set of
+    parses that has been found by the chart parser.
+
+    :ivar _restart: Records whether the parser's strategy, grammar,
+        or chart has been changed.  If so, then ``step`` must restart
+        the parsing algorithm.
+    """
+
+    def __init__(self, grammar, strategy=[], trace=0):
+        self._chart = None
+        self._current_chartrule = None
+        self._restart = False
+        ChartParser.__init__(self, grammar, strategy, trace)
+
+    # ////////////////////////////////////////////////////////////
+    # Initialization
+    # ////////////////////////////////////////////////////////////
+
+    def initialize(self, tokens):
+        "Begin parsing the given tokens."
+        self._chart = Chart(list(tokens))
+        self._restart = True
+
+    # ////////////////////////////////////////////////////////////
+    # Stepping
+    # ////////////////////////////////////////////////////////////
+
+    def step(self):
+        """
+        Return a generator that adds edges to the chart, one at a
+        time.  Each time the generator is resumed, it adds a single
+        edge and yields that edge.  If no more edges can be added,
+        then it yields None.
+
+        If the parser's strategy, grammar, or chart is changed, then
+        the generator will continue adding edges using the new
+        strategy, grammar, or chart.
+
+        Note that this generator never terminates, since the grammar
+        or strategy might be changed to values that would add new
+        edges.  Instead, it yields None when no more edges can be
+        added with the current strategy and grammar.
+        """
+        if self._chart is None:
+            raise ValueError("Parser must be initialized first")
+        while True:
+            self._restart = False
+            w = 50 // (self._chart.num_leaves() + 1)
+
+            for e in self._parse():
+                if self._trace > 1:
+                    print(self._current_chartrule)
+                if self._trace > 0:
+                    print(self._chart.pretty_format_edge(e, w))
+                yield e
+                if self._restart:
+                    break
+            else:
+                yield None  # No more edges.
+
+    def _parse(self):
+        """
+        A generator that implements the actual parsing algorithm.
+        ``step`` iterates through this generator, and restarts it
+        whenever the parser's strategy, grammar, or chart is modified.
+        """
+        chart = self._chart
+        grammar = self._grammar
+        edges_added = 1
+        while edges_added > 0:
+            edges_added = 0
+            for rule in self._strategy:
+                self._current_chartrule = rule
+                for e in rule.apply_everywhere(chart, grammar):
+                    edges_added += 1
+                    yield e
+
+    # ////////////////////////////////////////////////////////////
+    # Accessors
+    # ////////////////////////////////////////////////////////////
+
+    def strategy(self):
+        "Return the strategy used by this parser."
+        return self._strategy
+
+    def grammar(self):
+        "Return the grammar used by this parser."
+        return self._grammar
+
+    def chart(self):
+        "Return the chart that is used by this parser."
+        return self._chart
+
+    def current_chartrule(self):
+        "Return the chart rule used to generate the most recent edge."
+        return self._current_chartrule
+
+    def parses(self, tree_class=Tree):
+        "Return the parse trees currently contained in the chart."
+        return self._chart.parses(self._grammar.start(), tree_class)
+
+    # ////////////////////////////////////////////////////////////
+    # Parser modification
+    # ////////////////////////////////////////////////////////////
+
+    def set_strategy(self, strategy):
+        """
+        Change the strategy that the parser uses to decide which edges
+        to add to the chart.
+
+        :type strategy: list(ChartRuleI)
+        :param strategy: A list of rules that should be used to decide
+            what edges to add to the chart.
+        """
+        if strategy == self._strategy:
+            return
+        self._strategy = strategy[:]  # Make a copy.
+        self._restart = True
+
+    def set_grammar(self, grammar):
+        "Change the grammar used by the parser."
+        if grammar is self._grammar:
+            return
+        self._grammar = grammar
+        self._restart = True
+
+    def set_chart(self, chart):
+        "Load a given chart into the chart parser."
+        if chart is self._chart:
+            return
+        self._chart = chart
+        self._restart = True
+
+    # ////////////////////////////////////////////////////////////
+    # Standard parser methods
+    # ////////////////////////////////////////////////////////////
+
+    def parse(self, tokens, tree_class=Tree):
+        tokens = list(tokens)
+        self._grammar.check_coverage(tokens)
+
+        # Initialize ourselves.
+        self.initialize(tokens)
+
+        # Step until no more edges are generated.
+        for e in self.step():
+            if e is None:
+                break
+
+        # Return an iterator of complete parses.
+        return self.parses(tree_class=tree_class)
+
+
+########################################################################
+##  Demo Code
+########################################################################
+
+
+def demo_grammar():
+    from nltk.grammar import CFG
+
+    return CFG.fromstring(
+        """
+S  -> NP VP
+PP -> "with" NP
+NP -> NP PP
+VP -> VP PP
+VP -> Verb NP
+VP -> Verb
+NP -> Det Noun
+NP -> "John"
+NP -> "I"
+Det -> "the"
+Det -> "my"
+Det -> "a"
+Noun -> "dog"
+Noun -> "cookie"
+Verb -> "ate"
+Verb -> "saw"
+Prep -> "with"
+Prep -> "under"
+"""
+    )
+
+
+def demo(
+    choice=None,
+    print_times=True,
+    print_grammar=False,
+    print_trees=True,
+    trace=2,
+    sent="I saw John with a dog with my cookie",
+    numparses=5,
+):
+    """
+    A demonstration of the chart parsers.
+    """
+    import sys
+    import time
+
+    from nltk import CFG, Production, nonterminals
+
+    # The grammar for ChartParser and SteppingChartParser:
+    grammar = demo_grammar()
+    if print_grammar:
+        print("* Grammar")
+        print(grammar)
+
+    # Tokenize the sample sentence.
+    print("* Sentence:")
+    print(sent)
+    tokens = sent.split()
+    print(tokens)
+    print()
+
+    # Ask the user which parser to test,
+    # if the parser wasn't provided as an argument
+    if choice is None:
+        print("  1: Top-down chart parser")
+        print("  2: Bottom-up chart parser")
+        print("  3: Bottom-up left-corner chart parser")
+        print("  4: Left-corner chart parser with bottom-up filter")
+        print("  5: Stepping chart parser (alternating top-down & bottom-up)")
+        print("  6: All parsers")
+        print("\nWhich parser (1-6)? ", end=" ")
+        choice = sys.stdin.readline().strip()
+        print()
+
+    choice = str(choice)
+    if choice not in "123456":
+        print("Bad parser number")
+        return
+
+    # Keep track of how long each parser takes.
+    times = {}
+
+    strategies = {
+        "1": ("Top-down", TD_STRATEGY),
+        "2": ("Bottom-up", BU_STRATEGY),
+        "3": ("Bottom-up left-corner", BU_LC_STRATEGY),
+        "4": ("Filtered left-corner", LC_STRATEGY),
+    }
+    choices = []
+    if choice in strategies:
+        choices = [choice]
+    if choice == "6":
+        choices = "1234"
+
+    # Run the requested chart parser(s), except the stepping parser.
+    for strategy in choices:
+        print("* Strategy: " + strategies[strategy][0])
+        print()
+        cp = ChartParser(grammar, strategies[strategy][1], trace=trace)
+        t = time.time()
+        chart = cp.chart_parse(tokens)
+        parses = list(chart.parses(grammar.start()))
+
+        times[strategies[strategy][0]] = time.time() - t
+        print("Nr edges in chart:", len(chart.edges()))
+        if numparses:
+            assert len(parses) == numparses, "Not all parses found"
+        if print_trees:
+            for tree in parses:
+                print(tree)
+        else:
+            print("Nr trees:", len(parses))
+        print()
+
+    # Run the stepping parser, if requested.
+    if choice in "56":
+        print("* Strategy: Stepping (top-down vs bottom-up)")
+        print()
+        t = time.time()
+        cp = SteppingChartParser(grammar, trace=trace)
+        cp.initialize(tokens)
+        for i in range(5):
+            print("*** SWITCH TO TOP DOWN")
+            cp.set_strategy(TD_STRATEGY)
+            for j, e in enumerate(cp.step()):
+                if j > 20 or e is None:
+                    break
+            print("*** SWITCH TO BOTTOM UP")
+            cp.set_strategy(BU_STRATEGY)
+            for j, e in enumerate(cp.step()):
+                if j > 20 or e is None:
+                    break
+        times["Stepping"] = time.time() - t
+        print("Nr edges in chart:", len(cp.chart().edges()))
+        if numparses:
+            assert len(list(cp.parses())) == numparses, "Not all parses found"
+        if print_trees:
+            for tree in cp.parses():
+                print(tree)
+        else:
+            print("Nr trees:", len(list(cp.parses())))
+        print()
+
+    # Print the times of all parsers:
+    if not (print_times and times):
+        return
+    print("* Parsing times")
+    print()
+    maxlen = max(len(key) for key in times)
+    format = "%" + repr(maxlen) + "s parser: %6.3fsec"
+    times_items = times.items()
+    for (parser, t) in sorted(times_items, key=lambda a: a[1]):
+        print(format % (parser, t))
+
+
+if __name__ == "__main__":
+    demo()

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

@@ -0,0 +1,799 @@
+# Natural Language Toolkit: Dependency Grammars
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Jason Narad <[email protected]>
+#         Steven Bird <[email protected]> (modifications)
+#
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+"""
+Tools for reading and writing dependency trees.
+The input is assumed to be in Malt-TAB format
+(https://stp.lingfil.uu.se/~nivre/research/MaltXML.html).
+"""
+
+import subprocess
+import warnings
+from collections import defaultdict
+from itertools import chain
+from pprint import pformat
+
+from nltk.internals import find_binary
+from nltk.tree import Tree
+
+#################################################################
+# DependencyGraph Class
+#################################################################
+
+
+class DependencyGraph:
+    """
+    A container for the nodes and labelled edges of a dependency structure.
+    """
+
+    def __init__(
+        self,
+        tree_str=None,
+        cell_extractor=None,
+        zero_based=False,
+        cell_separator=None,
+        top_relation_label="ROOT",
+    ):
+        """Dependency graph.
+
+        We place a dummy `TOP` node with the index 0, since the root node is
+        often assigned 0 as its head. This also means that the indexing of the
+        nodes corresponds directly to the Malt-TAB format, which starts at 1.
+
+        If zero-based is True, then Malt-TAB-like input with node numbers
+        starting at 0 and the root node assigned -1 (as produced by, e.g.,
+        zpar).
+
+        :param str cell_separator: the cell separator. If not provided, cells
+            are split by whitespace.
+
+        :param str top_relation_label: the label by which the top relation is
+            identified, for examlple, `ROOT`, `null` or `TOP`.
+        """
+        self.nodes = defaultdict(
+            lambda: {
+                "address": None,
+                "word": None,
+                "lemma": None,
+                "ctag": None,
+                "tag": None,
+                "feats": None,
+                "head": None,
+                "deps": defaultdict(list),
+                "rel": None,
+            }
+        )
+
+        self.nodes[0].update({"ctag": "TOP", "tag": "TOP", "address": 0})
+
+        self.root = None
+
+        if tree_str:
+            self._parse(
+                tree_str,
+                cell_extractor=cell_extractor,
+                zero_based=zero_based,
+                cell_separator=cell_separator,
+                top_relation_label=top_relation_label,
+            )
+
+    def remove_by_address(self, address):
+        """
+        Removes the node with the given address.  References
+        to this node in others will still exist.
+        """
+        del self.nodes[address]
+
+    def redirect_arcs(self, originals, redirect):
+        """
+        Redirects arcs to any of the nodes in the originals list
+        to the redirect node address.
+        """
+        for node in self.nodes.values():
+            new_deps = []
+            for dep in node["deps"]:
+                if dep in originals:
+                    new_deps.append(redirect)
+                else:
+                    new_deps.append(dep)
+            node["deps"] = new_deps
+
+    def add_arc(self, head_address, mod_address):
+        """
+        Adds an arc from the node specified by head_address to the
+        node specified by the mod address.
+        """
+        relation = self.nodes[mod_address]["rel"]
+        self.nodes[head_address]["deps"].setdefault(relation, [])
+        self.nodes[head_address]["deps"][relation].append(mod_address)
+        # self.nodes[head_address]['deps'].append(mod_address)
+
+    def connect_graph(self):
+        """
+        Fully connects all non-root nodes.  All nodes are set to be dependents
+        of the root node.
+        """
+        for node1 in self.nodes.values():
+            for node2 in self.nodes.values():
+                if node1["address"] != node2["address"] and node2["rel"] != "TOP":
+                    relation = node2["rel"]
+                    node1["deps"].setdefault(relation, [])
+                    node1["deps"][relation].append(node2["address"])
+                    # node1['deps'].append(node2['address'])
+
+    def get_by_address(self, node_address):
+        """Return the node with the given address."""
+        return self.nodes[node_address]
+
+    def contains_address(self, node_address):
+        """
+        Returns true if the graph contains a node with the given node
+        address, false otherwise.
+        """
+        return node_address in self.nodes
+
+    def to_dot(self):
+        """Return a dot representation suitable for using with Graphviz.
+
+        >>> dg = DependencyGraph(
+        ...     'John N 2\\n'
+        ...     'loves V 0\\n'
+        ...     'Mary N 2'
+        ... )
+        >>> print(dg.to_dot())
+        digraph G{
+        edge [dir=forward]
+        node [shape=plaintext]
+        <BLANKLINE>
+        0 [label="0 (None)"]
+        0 -> 2 [label="ROOT"]
+        1 [label="1 (John)"]
+        2 [label="2 (loves)"]
+        2 -> 1 [label=""]
+        2 -> 3 [label=""]
+        3 [label="3 (Mary)"]
+        }
+
+        """
+        # Start the digraph specification
+        s = "digraph G{\n"
+        s += "edge [dir=forward]\n"
+        s += "node [shape=plaintext]\n"
+
+        # Draw the remaining nodes
+        for node in sorted(self.nodes.values(), key=lambda v: v["address"]):
+            s += '\n{} [label="{} ({})"]'.format(
+                node["address"],
+                node["address"],
+                node["word"],
+            )
+            for rel, deps in node["deps"].items():
+                for dep in deps:
+                    if rel is not None:
+                        s += '\n{} -> {} [label="{}"]'.format(node["address"], dep, rel)
+                    else:
+                        s += "\n{} -> {} ".format(node["address"], dep)
+        s += "\n}"
+
+        return s
+
+    def _repr_svg_(self):
+        """Show SVG representation of the transducer (IPython magic).
+        >>> from nltk.test.setup_fixt import check_binary
+        >>> check_binary('dot')
+        >>> dg = DependencyGraph(
+        ...     'John N 2\\n'
+        ...     'loves V 0\\n'
+        ...     'Mary N 2'
+        ... )
+        >>> dg._repr_svg_().split('\\n')[0]
+        '<?xml version="1.0" encoding="UTF-8" standalone="no"?>'
+
+        """
+        dot_string = self.to_dot()
+        return dot2img(dot_string)
+
+    def __str__(self):
+        return pformat(self.nodes)
+
+    def __repr__(self):
+        return f"<DependencyGraph with {len(self.nodes)} nodes>"
+
+    @staticmethod
+    def load(
+        filename, zero_based=False, cell_separator=None, top_relation_label="ROOT"
+    ):
+        """
+        :param filename: a name of a file in Malt-TAB format
+        :param zero_based: nodes in the input file are numbered starting from 0
+            rather than 1 (as produced by, e.g., zpar)
+        :param str cell_separator: the cell separator. If not provided, cells
+            are split by whitespace.
+        :param str top_relation_label: the label by which the top relation is
+            identified, for examlple, `ROOT`, `null` or `TOP`.
+
+        :return: a list of DependencyGraphs
+
+        """
+        with open(filename) as infile:
+            return [
+                DependencyGraph(
+                    tree_str,
+                    zero_based=zero_based,
+                    cell_separator=cell_separator,
+                    top_relation_label=top_relation_label,
+                )
+                for tree_str in infile.read().split("\n\n")
+            ]
+
+    def left_children(self, node_index):
+        """
+        Returns the number of left children under the node specified
+        by the given address.
+        """
+        children = chain.from_iterable(self.nodes[node_index]["deps"].values())
+        index = self.nodes[node_index]["address"]
+        return sum(1 for c in children if c < index)
+
+    def right_children(self, node_index):
+        """
+        Returns the number of right children under the node specified
+        by the given address.
+        """
+        children = chain.from_iterable(self.nodes[node_index]["deps"].values())
+        index = self.nodes[node_index]["address"]
+        return sum(1 for c in children if c > index)
+
+    def add_node(self, node):
+        if not self.contains_address(node["address"]):
+            self.nodes[node["address"]].update(node)
+
+    def _parse(
+        self,
+        input_,
+        cell_extractor=None,
+        zero_based=False,
+        cell_separator=None,
+        top_relation_label="ROOT",
+    ):
+        """Parse a sentence.
+
+        :param extractor: a function that given a tuple of cells returns a
+        7-tuple, where the values are ``word, lemma, ctag, tag, feats, head,
+        rel``.
+
+        :param str cell_separator: the cell separator. If not provided, cells
+        are split by whitespace.
+
+        :param str top_relation_label: the label by which the top relation is
+        identified, for examlple, `ROOT`, `null` or `TOP`.
+
+        """
+
+        def extract_3_cells(cells, index):
+            word, tag, head = cells
+            return index, word, word, tag, tag, "", head, ""
+
+        def extract_4_cells(cells, index):
+            word, tag, head, rel = cells
+            return index, word, word, tag, tag, "", head, rel
+
+        def extract_7_cells(cells, index):
+            line_index, word, lemma, tag, _, head, rel = cells
+            try:
+                index = int(line_index)
+            except ValueError:
+                # index can't be parsed as an integer, use default
+                pass
+            return index, word, lemma, tag, tag, "", head, rel
+
+        def extract_10_cells(cells, index):
+            line_index, word, lemma, ctag, tag, feats, head, rel, _, _ = cells
+            try:
+                index = int(line_index)
+            except ValueError:
+                # index can't be parsed as an integer, use default
+                pass
+            return index, word, lemma, ctag, tag, feats, head, rel
+
+        extractors = {
+            3: extract_3_cells,
+            4: extract_4_cells,
+            7: extract_7_cells,
+            10: extract_10_cells,
+        }
+
+        if isinstance(input_, str):
+            input_ = (line for line in input_.split("\n"))
+
+        lines = (l.rstrip() for l in input_)
+        lines = (l for l in lines if l)
+
+        cell_number = None
+        for index, line in enumerate(lines, start=1):
+            cells = line.split(cell_separator)
+            if cell_number is None:
+                cell_number = len(cells)
+            else:
+                assert cell_number == len(cells)
+
+            if cell_extractor is None:
+                try:
+                    cell_extractor = extractors[cell_number]
+                except KeyError as e:
+                    raise ValueError(
+                        "Number of tab-delimited fields ({}) not supported by "
+                        "CoNLL(10) or Malt-Tab(4) format".format(cell_number)
+                    ) from e
+
+            try:
+                index, word, lemma, ctag, tag, feats, head, rel = cell_extractor(
+                    cells, index
+                )
+            except (TypeError, ValueError):
+                # cell_extractor doesn't take 2 arguments or doesn't return 8
+                # values; assume the cell_extractor is an older external
+                # extractor and doesn't accept or return an index.
+                word, lemma, ctag, tag, feats, head, rel = cell_extractor(cells)
+
+            if head == "_":
+                continue
+
+            head = int(head)
+            if zero_based:
+                head += 1
+
+            self.nodes[index].update(
+                {
+                    "address": index,
+                    "word": word,
+                    "lemma": lemma,
+                    "ctag": ctag,
+                    "tag": tag,
+                    "feats": feats,
+                    "head": head,
+                    "rel": rel,
+                }
+            )
+
+            # Make sure that the fake root node has labeled dependencies.
+            if (cell_number == 3) and (head == 0):
+                rel = top_relation_label
+            self.nodes[head]["deps"][rel].append(index)
+
+        if self.nodes[0]["deps"][top_relation_label]:
+            root_address = self.nodes[0]["deps"][top_relation_label][0]
+            self.root = self.nodes[root_address]
+            self.top_relation_label = top_relation_label
+        else:
+            warnings.warn(
+                "The graph doesn't contain a node " "that depends on the root element."
+            )
+
+    def _word(self, node, filter=True):
+        w = node["word"]
+        if filter:
+            if w != ",":
+                return w
+        return w
+
+    def _tree(self, i):
+        """Turn dependency graphs into NLTK trees.
+
+        :param int i: index of a node
+        :return: either a word (if the indexed node is a leaf) or a ``Tree``.
+        """
+        node = self.get_by_address(i)
+        word = node["word"]
+        deps = sorted(chain.from_iterable(node["deps"].values()))
+
+        if deps:
+            return Tree(word, [self._tree(dep) for dep in deps])
+        else:
+            return word
+
+    def tree(self):
+        """
+        Starting with the ``root`` node, build a dependency tree using the NLTK
+        ``Tree`` constructor. Dependency labels are omitted.
+        """
+        node = self.root
+
+        word = node["word"]
+        deps = sorted(chain.from_iterable(node["deps"].values()))
+        return Tree(word, [self._tree(dep) for dep in deps])
+
+    def triples(self, node=None):
+        """
+        Extract dependency triples of the form:
+        ((head word, head tag), rel, (dep word, dep tag))
+        """
+
+        if not node:
+            node = self.root
+
+        head = (node["word"], node["ctag"])
+        for i in sorted(chain.from_iterable(node["deps"].values())):
+            dep = self.get_by_address(i)
+            yield (head, dep["rel"], (dep["word"], dep["ctag"]))
+            yield from self.triples(node=dep)
+
+    def _hd(self, i):
+        try:
+            return self.nodes[i]["head"]
+        except IndexError:
+            return None
+
+    def _rel(self, i):
+        try:
+            return self.nodes[i]["rel"]
+        except IndexError:
+            return None
+
+    # what's the return type?  Boolean or list?
+    def contains_cycle(self):
+        """Check whether there are cycles.
+
+        >>> dg = DependencyGraph(treebank_data)
+        >>> dg.contains_cycle()
+        False
+
+        >>> cyclic_dg = DependencyGraph()
+        >>> top = {'word': None, 'deps': [1], 'rel': 'TOP', 'address': 0}
+        >>> child1 = {'word': None, 'deps': [2], 'rel': 'NTOP', 'address': 1}
+        >>> child2 = {'word': None, 'deps': [4], 'rel': 'NTOP', 'address': 2}
+        >>> child3 = {'word': None, 'deps': [1], 'rel': 'NTOP', 'address': 3}
+        >>> child4 = {'word': None, 'deps': [3], 'rel': 'NTOP', 'address': 4}
+        >>> cyclic_dg.nodes = {
+        ...     0: top,
+        ...     1: child1,
+        ...     2: child2,
+        ...     3: child3,
+        ...     4: child4,
+        ... }
+        >>> cyclic_dg.root = top
+
+        >>> cyclic_dg.contains_cycle()
+        [1, 2, 4, 3]
+
+        """
+        distances = {}
+
+        for node in self.nodes.values():
+            for dep in node["deps"]:
+                key = tuple([node["address"], dep])
+                distances[key] = 1
+
+        for _ in self.nodes:
+            new_entries = {}
+
+            for pair1 in distances:
+                for pair2 in distances:
+                    if pair1[1] == pair2[0]:
+                        key = tuple([pair1[0], pair2[1]])
+                        new_entries[key] = distances[pair1] + distances[pair2]
+
+            for pair in new_entries:
+                distances[pair] = new_entries[pair]
+                if pair[0] == pair[1]:
+                    path = self.get_cycle_path(self.get_by_address(pair[0]), pair[0])
+                    return path
+
+        return False  # return []?
+
+    def get_cycle_path(self, curr_node, goal_node_index):
+        for dep in curr_node["deps"]:
+            if dep == goal_node_index:
+                return [curr_node["address"]]
+        for dep in curr_node["deps"]:
+            path = self.get_cycle_path(self.get_by_address(dep), goal_node_index)
+            if len(path) > 0:
+                path.insert(0, curr_node["address"])
+                return path
+        return []
+
+    def to_conll(self, style):
+        """
+        The dependency graph in CoNLL format.
+
+        :param style: the style to use for the format (3, 4, 10 columns)
+        :type style: int
+        :rtype: str
+        """
+
+        if style == 3:
+            template = "{word}\t{tag}\t{head}\n"
+        elif style == 4:
+            template = "{word}\t{tag}\t{head}\t{rel}\n"
+        elif style == 10:
+            template = (
+                "{i}\t{word}\t{lemma}\t{ctag}\t{tag}\t{feats}\t{head}\t{rel}\t_\t_\n"
+            )
+        else:
+            raise ValueError(
+                "Number of tab-delimited fields ({}) not supported by "
+                "CoNLL(10) or Malt-Tab(4) format".format(style)
+            )
+
+        return "".join(
+            template.format(i=i, **node)
+            for i, node in sorted(self.nodes.items())
+            if node["tag"] != "TOP"
+        )
+
+    def nx_graph(self):
+        """Convert the data in a ``nodelist`` into a networkx labeled directed graph."""
+        import networkx
+
+        nx_nodelist = list(range(1, len(self.nodes)))
+        nx_edgelist = [
+            (n, self._hd(n), self._rel(n)) for n in nx_nodelist if self._hd(n)
+        ]
+        self.nx_labels = {}
+        for n in nx_nodelist:
+            self.nx_labels[n] = self.nodes[n]["word"]
+
+        g = networkx.MultiDiGraph()
+        g.add_nodes_from(nx_nodelist)
+        g.add_edges_from(nx_edgelist)
+
+        return g
+
+
+def dot2img(dot_string, t="svg"):
+    """
+    Create image representation fom dot_string, using the 'dot' program
+    from the Graphviz package.
+
+    Use the 't' argument to specify the image file format, for ex. 'jpeg', 'eps',
+    'json', 'png' or 'webp' (Running 'dot -T:' lists all available formats).
+
+    Note that the "capture_output" option of subprocess.run() is only available
+    with text formats (like svg), but not with binary image formats (like png).
+    """
+
+    try:
+        find_binary("dot")
+        try:
+            if t in ["dot", "dot_json", "json", "svg"]:
+                proc = subprocess.run(
+                    ["dot", "-T%s" % t],
+                    capture_output=True,
+                    input=dot_string,
+                    text=True,
+                )
+            else:
+                proc = subprocess.run(
+                    ["dot", "-T%s" % t],
+                    input=bytes(dot_string, encoding="utf8"),
+                )
+            return proc.stdout
+        except:
+            raise Exception(
+                "Cannot create image representation by running dot from string: {}"
+                "".format(dot_string)
+            )
+    except OSError as e:
+        raise Exception("Cannot find the dot binary from Graphviz package") from e
+
+
+class DependencyGraphError(Exception):
+    """Dependency graph exception."""
+
+
+def demo():
+    malt_demo()
+    conll_demo()
+    conll_file_demo()
+    cycle_finding_demo()
+
+
+def malt_demo(nx=False):
+    """
+    A demonstration of the result of reading a dependency
+    version of the first sentence of the Penn Treebank.
+    """
+    dg = DependencyGraph(
+        """Pierre  NNP     2       NMOD
+Vinken  NNP     8       SUB
+,       ,       2       P
+61      CD      5       NMOD
+years   NNS     6       AMOD
+old     JJ      2       NMOD
+,       ,       2       P
+will    MD      0       ROOT
+join    VB      8       VC
+the     DT      11      NMOD
+board   NN      9       OBJ
+as      IN      9       VMOD
+a       DT      15      NMOD
+nonexecutive    JJ      15      NMOD
+director        NN      12      PMOD
+Nov.    NNP     9       VMOD
+29      CD      16      NMOD
+.       .       9       VMOD
+"""
+    )
+    tree = dg.tree()
+    tree.pprint()
+    if nx:
+        # currently doesn't work
+        import networkx
+        from matplotlib import pylab
+
+        g = dg.nx_graph()
+        g.info()
+        pos = networkx.spring_layout(g, dim=1)
+        networkx.draw_networkx_nodes(g, pos, node_size=50)
+        # networkx.draw_networkx_edges(g, pos, edge_color='k', width=8)
+        networkx.draw_networkx_labels(g, pos, dg.nx_labels)
+        pylab.xticks([])
+        pylab.yticks([])
+        pylab.savefig("tree.png")
+        pylab.show()
+
+
+def conll_demo():
+    """
+    A demonstration of how to read a string representation of
+    a CoNLL format dependency tree.
+    """
+    dg = DependencyGraph(conll_data1)
+    tree = dg.tree()
+    tree.pprint()
+    print(dg)
+    print(dg.to_conll(4))
+
+
+def conll_file_demo():
+    print("Mass conll_read demo...")
+    graphs = [DependencyGraph(entry) for entry in conll_data2.split("\n\n") if entry]
+    for graph in graphs:
+        tree = graph.tree()
+        print("\n")
+        tree.pprint()
+
+
+def cycle_finding_demo():
+    dg = DependencyGraph(treebank_data)
+    print(dg.contains_cycle())
+    cyclic_dg = DependencyGraph()
+    cyclic_dg.add_node({"word": None, "deps": [1], "rel": "TOP", "address": 0})
+    cyclic_dg.add_node({"word": None, "deps": [2], "rel": "NTOP", "address": 1})
+    cyclic_dg.add_node({"word": None, "deps": [4], "rel": "NTOP", "address": 2})
+    cyclic_dg.add_node({"word": None, "deps": [1], "rel": "NTOP", "address": 3})
+    cyclic_dg.add_node({"word": None, "deps": [3], "rel": "NTOP", "address": 4})
+    print(cyclic_dg.contains_cycle())
+
+
+treebank_data = """Pierre  NNP     2       NMOD
+Vinken  NNP     8       SUB
+,       ,       2       P
+61      CD      5       NMOD
+years   NNS     6       AMOD
+old     JJ      2       NMOD
+,       ,       2       P
+will    MD      0       ROOT
+join    VB      8       VC
+the     DT      11      NMOD
+board   NN      9       OBJ
+as      IN      9       VMOD
+a       DT      15      NMOD
+nonexecutive    JJ      15      NMOD
+director        NN      12      PMOD
+Nov.    NNP     9       VMOD
+29      CD      16      NMOD
+.       .       9       VMOD
+"""
+
+conll_data1 = """
+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   _  _
+"""
+
+conll_data2 = """1   Cathy             Cathy             N     N     eigen|ev|neut                    2   su      _  _
+2   zag               zie               V     V     trans|ovt|1of2of3|ev             0   ROOT    _  _
+3   hen               hen               Pron  Pron  per|3|mv|datofacc                2   obj1    _  _
+4   wild              wild              Adj   Adj   attr|stell|onverv                5   mod     _  _
+5   zwaaien           zwaai             N     N     soort|mv|neut                    2   vc      _  _
+6   .                 .                 Punc  Punc  punt                             5   punct   _  _
+
+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   _  _
+
+1   Dat               dat               Pron  Pron  aanw|neut|attr                   2   det     _  _
+2   werkwoord         werkwoord         N     N     soort|ev|neut                    6   obj1    _  _
+3   had               heb               V     V     hulp|ovt|1of2of3|ev              0   ROOT    _  _
+4   ze                ze                Pron  Pron  per|3|evofmv|nom                 6   su      _  _
+5   zelf              zelf              Pron  Pron  aanw|neut|attr|wzelf             3   predm   _  _
+6   uitgevonden       vind              V     V     trans|verldw|onverv              3   vc      _  _
+7   .                 .                 Punc  Punc  punt                             6   punct   _  _
+
+1   Het               het               Pron  Pron  onbep|neut|zelfst                2   su      _  _
+2   hoorde            hoor              V     V     trans|ovt|1of2of3|ev             0   ROOT    _  _
+3   bij               bij               Prep  Prep  voor                             2   ld      _  _
+4   de                de                Art   Art   bep|zijdofmv|neut                6   det     _  _
+5   warme             warm              Adj   Adj   attr|stell|vervneut              6   mod     _  _
+6   zomerdag          zomerdag          N     N     soort|ev|neut                    3   obj1    _  _
+7   die               die               Pron  Pron  betr|neut|zelfst                 6   mod     _  _
+8   ze                ze                Pron  Pron  per|3|evofmv|nom                 12  su      _  _
+9   ginds             ginds             Adv   Adv   gew|aanw                         12  mod     _  _
+10  achter            achter            Adv   Adv   gew|geenfunc|stell|onverv        12  svp     _  _
+11  had               heb               V     V     hulp|ovt|1of2of3|ev              7   body    _  _
+12  gelaten           laat              V     V     trans|verldw|onverv              11  vc      _  _
+13  .                 .                 Punc  Punc  punt                             12  punct   _  _
+
+1   Ze                ze                Pron  Pron  per|3|evofmv|nom                 2   su      _  _
+2   hadden            heb               V     V     trans|ovt|1of2of3|mv             0   ROOT    _  _
+3   languit           languit           Adv   Adv   gew|geenfunc|stell|onverv        11  mod     _  _
+4   naast             naast             Prep  Prep  voor                             11  mod     _  _
+5   elkaar            elkaar            Pron  Pron  rec|neut                         4   obj1    _  _
+6   op                op                Prep  Prep  voor                             11  ld      _  _
+7   de                de                Art   Art   bep|zijdofmv|neut                8   det     _  _
+8   strandstoelen     strandstoel       N     N     soort|mv|neut                    6   obj1    _  _
+9   kunnen            kan               V     V     hulp|inf                         2   vc      _  _
+10  gaan              ga                V     V     hulp|inf                         9   vc      _  _
+11  liggen            lig               V     V     intrans|inf                      10  vc      _  _
+12  .                 .                 Punc  Punc  punt                             11  punct   _  _
+
+1   Zij               zij               Pron  Pron  per|3|evofmv|nom                 2   su      _  _
+2   zou               zal               V     V     hulp|ovt|1of2of3|ev              7   cnj     _  _
+3   mams              mams              N     N     soort|ev|neut                    4   det     _  _
+4   rug               rug               N     N     soort|ev|neut                    5   obj1    _  _
+5   ingewreven        wrijf             V     V     trans|verldw|onverv              6   vc      _  _
+6   hebben            heb               V     V     hulp|inf                         2   vc      _  _
+7   en                en                Conj  Conj  neven                            0   ROOT    _  _
+8   mam               mam               V     V     trans|ovt|1of2of3|ev             7   cnj     _  _
+9   de                de                Art   Art   bep|zijdofmv|neut                10  det     _  _
+10  hare              hare              Pron  Pron  bez|3|ev|neut|attr               8   obj1    _  _
+11  .                 .                 Punc  Punc  punt                             10  punct   _  _
+
+1   Of                of                Conj  Conj  onder|metfin                     0   ROOT    _  _
+2   ze                ze                Pron  Pron  per|3|evofmv|nom                 3   su      _  _
+3   had               heb               V     V     hulp|ovt|1of2of3|ev              0   ROOT    _  _
+4   gewoon            gewoon            Adj   Adj   adv|stell|onverv                 10  mod     _  _
+5   met               met               Prep  Prep  voor                             10  mod     _  _
+6   haar              haar              Pron  Pron  bez|3|ev|neut|attr               7   det     _  _
+7   vriendinnen       vriendin          N     N     soort|mv|neut                    5   obj1    _  _
+8   rond              rond              Adv   Adv   deelv                            10  svp     _  _
+9   kunnen            kan               V     V     hulp|inf                         3   vc      _  _
+10  slenteren         slenter           V     V     intrans|inf                      9   vc      _  _
+11  in                in                Prep  Prep  voor                             10  mod     _  _
+12  de                de                Art   Art   bep|zijdofmv|neut                13  det     _  _
+13  buurt             buurt             N     N     soort|ev|neut                    11  obj1    _  _
+14  van               van               Prep  Prep  voor                             13  mod     _  _
+15  Trafalgar_Square  Trafalgar_Square  MWU   N_N   eigen|ev|neut_eigen|ev|neut      14  obj1    _  _
+16  .                 .                 Punc  Punc  punt                             15  punct   _  _
+"""
+
+if __name__ == "__main__":
+    demo()

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

@@ -0,0 +1,552 @@
+# Natural Language Toolkit: An Incremental Earley Chart Parser
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Peter Ljunglöf <[email protected]>
+#         Rob Speer <[email protected]>
+#         Edward Loper <[email protected]>
+#         Steven Bird <[email protected]>
+#         Jean Mark Gawron <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Data classes and parser implementations for *incremental* chart
+parsers, which use dynamic programming to efficiently parse a text.
+A "chart parser" derives parse trees for a text by iteratively adding
+\"edges\" to a \"chart\".  Each "edge" represents a hypothesis about the tree
+structure for a subsequence of the text.  The "chart" is a
+\"blackboard\" for composing and combining these hypotheses.
+
+A parser is "incremental", if it guarantees that for all i, j where i < j,
+all edges ending at i are built before any edges ending at j.
+This is appealing for, say, speech recognizer hypothesis filtering.
+
+The main parser class is ``EarleyChartParser``, which is a top-down
+algorithm, originally formulated by Jay Earley (1970).
+"""
+
+from time import perf_counter
+
+from nltk.parse.chart import (
+    BottomUpPredictCombineRule,
+    BottomUpPredictRule,
+    CachedTopDownPredictRule,
+    Chart,
+    ChartParser,
+    EdgeI,
+    EmptyPredictRule,
+    FilteredBottomUpPredictCombineRule,
+    FilteredSingleEdgeFundamentalRule,
+    LeafEdge,
+    LeafInitRule,
+    SingleEdgeFundamentalRule,
+    TopDownInitRule,
+)
+from nltk.parse.featurechart import (
+    FeatureBottomUpPredictCombineRule,
+    FeatureBottomUpPredictRule,
+    FeatureChart,
+    FeatureChartParser,
+    FeatureEmptyPredictRule,
+    FeatureSingleEdgeFundamentalRule,
+    FeatureTopDownInitRule,
+    FeatureTopDownPredictRule,
+)
+
+# ////////////////////////////////////////////////////////////
+# Incremental Chart
+# ////////////////////////////////////////////////////////////
+
+
+class IncrementalChart(Chart):
+    def initialize(self):
+        # A sequence of edge lists contained in this chart.
+        self._edgelists = tuple([] for x in self._positions())
+
+        # The set of child pointer lists associated with each edge.
+        self._edge_to_cpls = {}
+
+        # Indexes mapping attribute values to lists of edges
+        # (used by select()).
+        self._indexes = {}
+
+    def edges(self):
+        return list(self.iteredges())
+
+    def iteredges(self):
+        return (edge for edgelist in self._edgelists for edge in edgelist)
+
+    def select(self, end, **restrictions):
+        edgelist = self._edgelists[end]
+
+        # If there are no restrictions, then return all edges.
+        if restrictions == {}:
+            return iter(edgelist)
+
+        # Find the index corresponding to the given restrictions.
+        restr_keys = sorted(restrictions.keys())
+        restr_keys = tuple(restr_keys)
+
+        # If it doesn't exist, then create it.
+        if restr_keys not in self._indexes:
+            self._add_index(restr_keys)
+
+        vals = tuple(restrictions[key] for key in restr_keys)
+        return iter(self._indexes[restr_keys][end].get(vals, []))
+
+    def _add_index(self, restr_keys):
+        # Make sure it's a valid index.
+        for key in restr_keys:
+            if not hasattr(EdgeI, key):
+                raise ValueError("Bad restriction: %s" % key)
+
+        # Create the index.
+        index = self._indexes[restr_keys] = tuple({} for x in self._positions())
+
+        # Add all existing edges to the index.
+        for end, edgelist in enumerate(self._edgelists):
+            this_index = index[end]
+            for edge in edgelist:
+                vals = tuple(getattr(edge, key)() for key in restr_keys)
+                this_index.setdefault(vals, []).append(edge)
+
+    def _register_with_indexes(self, edge):
+        end = edge.end()
+        for (restr_keys, index) in self._indexes.items():
+            vals = tuple(getattr(edge, key)() for key in restr_keys)
+            index[end].setdefault(vals, []).append(edge)
+
+    def _append_edge(self, edge):
+        self._edgelists[edge.end()].append(edge)
+
+    def _positions(self):
+        return range(self.num_leaves() + 1)
+
+
+class FeatureIncrementalChart(IncrementalChart, FeatureChart):
+    def select(self, end, **restrictions):
+        edgelist = self._edgelists[end]
+
+        # If there are no restrictions, then return all edges.
+        if restrictions == {}:
+            return iter(edgelist)
+
+        # Find the index corresponding to the given restrictions.
+        restr_keys = sorted(restrictions.keys())
+        restr_keys = tuple(restr_keys)
+
+        # If it doesn't exist, then create it.
+        if restr_keys not in self._indexes:
+            self._add_index(restr_keys)
+
+        vals = tuple(
+            self._get_type_if_possible(restrictions[key]) for key in restr_keys
+        )
+        return iter(self._indexes[restr_keys][end].get(vals, []))
+
+    def _add_index(self, restr_keys):
+        # Make sure it's a valid index.
+        for key in restr_keys:
+            if not hasattr(EdgeI, key):
+                raise ValueError("Bad restriction: %s" % key)
+
+        # Create the index.
+        index = self._indexes[restr_keys] = tuple({} for x in self._positions())
+
+        # Add all existing edges to the index.
+        for end, edgelist in enumerate(self._edgelists):
+            this_index = index[end]
+            for edge in edgelist:
+                vals = tuple(
+                    self._get_type_if_possible(getattr(edge, key)())
+                    for key in restr_keys
+                )
+                this_index.setdefault(vals, []).append(edge)
+
+    def _register_with_indexes(self, edge):
+        end = edge.end()
+        for (restr_keys, index) in self._indexes.items():
+            vals = tuple(
+                self._get_type_if_possible(getattr(edge, key)()) for key in restr_keys
+            )
+            index[end].setdefault(vals, []).append(edge)
+
+
+# ////////////////////////////////////////////////////////////
+# Incremental CFG Rules
+# ////////////////////////////////////////////////////////////
+
+
+class CompleteFundamentalRule(SingleEdgeFundamentalRule):
+    def _apply_incomplete(self, chart, grammar, left_edge):
+        end = left_edge.end()
+        # When the chart is incremental, we only have to look for
+        # empty complete edges here.
+        for right_edge in chart.select(
+            start=end, end=end, is_complete=True, lhs=left_edge.nextsym()
+        ):
+            new_edge = left_edge.move_dot_forward(right_edge.end())
+            if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+                yield new_edge
+
+
+class CompleterRule(CompleteFundamentalRule):
+    _fundamental_rule = CompleteFundamentalRule()
+
+    def apply(self, chart, grammar, edge):
+        if not isinstance(edge, LeafEdge):
+            yield from self._fundamental_rule.apply(chart, grammar, edge)
+
+
+class ScannerRule(CompleteFundamentalRule):
+    _fundamental_rule = CompleteFundamentalRule()
+
+    def apply(self, chart, grammar, edge):
+        if isinstance(edge, LeafEdge):
+            yield from self._fundamental_rule.apply(chart, grammar, edge)
+
+
+class PredictorRule(CachedTopDownPredictRule):
+    pass
+
+
+class FilteredCompleteFundamentalRule(FilteredSingleEdgeFundamentalRule):
+    def apply(self, chart, grammar, edge):
+        # Since the Filtered rule only works for grammars without empty productions,
+        # we only have to bother with complete edges here.
+        if edge.is_complete():
+            yield from self._apply_complete(chart, grammar, edge)
+
+
+# ////////////////////////////////////////////////////////////
+# Incremental FCFG Rules
+# ////////////////////////////////////////////////////////////
+
+
+class FeatureCompleteFundamentalRule(FeatureSingleEdgeFundamentalRule):
+    def _apply_incomplete(self, chart, grammar, left_edge):
+        fr = self._fundamental_rule
+        end = left_edge.end()
+        # When the chart is incremental, we only have to look for
+        # empty complete edges here.
+        for right_edge in chart.select(
+            start=end, end=end, is_complete=True, lhs=left_edge.nextsym()
+        ):
+            yield from fr.apply(chart, grammar, left_edge, right_edge)
+
+
+class FeatureCompleterRule(CompleterRule):
+    _fundamental_rule = FeatureCompleteFundamentalRule()
+
+
+class FeatureScannerRule(ScannerRule):
+    _fundamental_rule = FeatureCompleteFundamentalRule()
+
+
+class FeaturePredictorRule(FeatureTopDownPredictRule):
+    pass
+
+
+# ////////////////////////////////////////////////////////////
+# Incremental CFG Chart Parsers
+# ////////////////////////////////////////////////////////////
+
+EARLEY_STRATEGY = [
+    LeafInitRule(),
+    TopDownInitRule(),
+    CompleterRule(),
+    ScannerRule(),
+    PredictorRule(),
+]
+TD_INCREMENTAL_STRATEGY = [
+    LeafInitRule(),
+    TopDownInitRule(),
+    CachedTopDownPredictRule(),
+    CompleteFundamentalRule(),
+]
+BU_INCREMENTAL_STRATEGY = [
+    LeafInitRule(),
+    EmptyPredictRule(),
+    BottomUpPredictRule(),
+    CompleteFundamentalRule(),
+]
+BU_LC_INCREMENTAL_STRATEGY = [
+    LeafInitRule(),
+    EmptyPredictRule(),
+    BottomUpPredictCombineRule(),
+    CompleteFundamentalRule(),
+]
+
+LC_INCREMENTAL_STRATEGY = [
+    LeafInitRule(),
+    FilteredBottomUpPredictCombineRule(),
+    FilteredCompleteFundamentalRule(),
+]
+
+
+class IncrementalChartParser(ChartParser):
+    """
+    An *incremental* chart parser implementing Jay Earley's
+    parsing algorithm:
+
+    | For each index end in [0, 1, ..., N]:
+    |   For each edge such that edge.end = end:
+    |     If edge is incomplete and edge.next is not a part of speech:
+    |       Apply PredictorRule to edge
+    |     If edge is incomplete and edge.next is a part of speech:
+    |       Apply ScannerRule to edge
+    |     If edge is complete:
+    |       Apply CompleterRule to edge
+    | Return any complete parses in the chart
+    """
+
+    def __init__(
+        self,
+        grammar,
+        strategy=BU_LC_INCREMENTAL_STRATEGY,
+        trace=0,
+        trace_chart_width=50,
+        chart_class=IncrementalChart,
+    ):
+        """
+        Create a new Earley chart parser, that uses ``grammar`` to
+        parse texts.
+
+        :type grammar: CFG
+        :param grammar: The grammar used to parse texts.
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            and higher numbers will produce more verbose tracing
+            output.
+        :type trace_chart_width: int
+        :param trace_chart_width: The default total width reserved for
+            the chart in trace output.  The remainder of each line will
+            be used to display edges.
+        :param chart_class: The class that should be used to create
+            the charts used by this parser.
+        """
+        self._grammar = grammar
+        self._trace = trace
+        self._trace_chart_width = trace_chart_width
+        self._chart_class = chart_class
+
+        self._axioms = []
+        self._inference_rules = []
+        for rule in strategy:
+            if rule.NUM_EDGES == 0:
+                self._axioms.append(rule)
+            elif rule.NUM_EDGES == 1:
+                self._inference_rules.append(rule)
+            else:
+                raise ValueError(
+                    "Incremental inference rules must have " "NUM_EDGES == 0 or 1"
+                )
+
+    def chart_parse(self, tokens, trace=None):
+        if trace is None:
+            trace = self._trace
+        trace_new_edges = self._trace_new_edges
+
+        tokens = list(tokens)
+        self._grammar.check_coverage(tokens)
+        chart = self._chart_class(tokens)
+        grammar = self._grammar
+
+        # Width, for printing trace edges.
+        trace_edge_width = self._trace_chart_width // (chart.num_leaves() + 1)
+        if trace:
+            print(chart.pretty_format_leaves(trace_edge_width))
+
+        for axiom in self._axioms:
+            new_edges = list(axiom.apply(chart, grammar))
+            trace_new_edges(chart, axiom, new_edges, trace, trace_edge_width)
+
+        inference_rules = self._inference_rules
+        for end in range(chart.num_leaves() + 1):
+            if trace > 1:
+                print("\n* Processing queue:", end, "\n")
+            agenda = list(chart.select(end=end))
+            while agenda:
+                edge = agenda.pop()
+                for rule in inference_rules:
+                    new_edges = list(rule.apply(chart, grammar, edge))
+                    trace_new_edges(chart, rule, new_edges, trace, trace_edge_width)
+                    for new_edge in new_edges:
+                        if new_edge.end() == end:
+                            agenda.append(new_edge)
+
+        return chart
+
+
+class EarleyChartParser(IncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        IncrementalChartParser.__init__(self, grammar, EARLEY_STRATEGY, **parser_args)
+
+
+class IncrementalTopDownChartParser(IncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        IncrementalChartParser.__init__(
+            self, grammar, TD_INCREMENTAL_STRATEGY, **parser_args
+        )
+
+
+class IncrementalBottomUpChartParser(IncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        IncrementalChartParser.__init__(
+            self, grammar, BU_INCREMENTAL_STRATEGY, **parser_args
+        )
+
+
+class IncrementalBottomUpLeftCornerChartParser(IncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        IncrementalChartParser.__init__(
+            self, grammar, BU_LC_INCREMENTAL_STRATEGY, **parser_args
+        )
+
+
+class IncrementalLeftCornerChartParser(IncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        if not grammar.is_nonempty():
+            raise ValueError(
+                "IncrementalLeftCornerParser only works for grammars "
+                "without empty productions."
+            )
+        IncrementalChartParser.__init__(
+            self, grammar, LC_INCREMENTAL_STRATEGY, **parser_args
+        )
+
+
+# ////////////////////////////////////////////////////////////
+# Incremental FCFG Chart Parsers
+# ////////////////////////////////////////////////////////////
+
+EARLEY_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureTopDownInitRule(),
+    FeatureCompleterRule(),
+    FeatureScannerRule(),
+    FeaturePredictorRule(),
+]
+TD_INCREMENTAL_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureTopDownInitRule(),
+    FeatureTopDownPredictRule(),
+    FeatureCompleteFundamentalRule(),
+]
+BU_INCREMENTAL_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureEmptyPredictRule(),
+    FeatureBottomUpPredictRule(),
+    FeatureCompleteFundamentalRule(),
+]
+BU_LC_INCREMENTAL_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureEmptyPredictRule(),
+    FeatureBottomUpPredictCombineRule(),
+    FeatureCompleteFundamentalRule(),
+]
+
+
+class FeatureIncrementalChartParser(IncrementalChartParser, FeatureChartParser):
+    def __init__(
+        self,
+        grammar,
+        strategy=BU_LC_INCREMENTAL_FEATURE_STRATEGY,
+        trace_chart_width=20,
+        chart_class=FeatureIncrementalChart,
+        **parser_args
+    ):
+        IncrementalChartParser.__init__(
+            self,
+            grammar,
+            strategy=strategy,
+            trace_chart_width=trace_chart_width,
+            chart_class=chart_class,
+            **parser_args
+        )
+
+
+class FeatureEarleyChartParser(FeatureIncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureIncrementalChartParser.__init__(
+            self, grammar, EARLEY_FEATURE_STRATEGY, **parser_args
+        )
+
+
+class FeatureIncrementalTopDownChartParser(FeatureIncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureIncrementalChartParser.__init__(
+            self, grammar, TD_INCREMENTAL_FEATURE_STRATEGY, **parser_args
+        )
+
+
+class FeatureIncrementalBottomUpChartParser(FeatureIncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureIncrementalChartParser.__init__(
+            self, grammar, BU_INCREMENTAL_FEATURE_STRATEGY, **parser_args
+        )
+
+
+class FeatureIncrementalBottomUpLeftCornerChartParser(FeatureIncrementalChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureIncrementalChartParser.__init__(
+            self, grammar, BU_LC_INCREMENTAL_FEATURE_STRATEGY, **parser_args
+        )
+
+
+# ////////////////////////////////////////////////////////////
+# Demonstration
+# ////////////////////////////////////////////////////////////
+
+
+def demo(
+    print_times=True,
+    print_grammar=False,
+    print_trees=True,
+    trace=2,
+    sent="I saw John with a dog with my cookie",
+    numparses=5,
+):
+    """
+    A demonstration of the Earley parsers.
+    """
+    import sys
+    import time
+
+    from nltk.parse.chart import demo_grammar
+
+    # The grammar for ChartParser and SteppingChartParser:
+    grammar = demo_grammar()
+    if print_grammar:
+        print("* Grammar")
+        print(grammar)
+
+    # Tokenize the sample sentence.
+    print("* Sentence:")
+    print(sent)
+    tokens = sent.split()
+    print(tokens)
+    print()
+
+    # Do the parsing.
+    earley = EarleyChartParser(grammar, trace=trace)
+    t = perf_counter()
+    chart = earley.chart_parse(tokens)
+    parses = list(chart.parses(grammar.start()))
+    t = perf_counter() - t
+
+    # Print results.
+    if numparses:
+        assert len(parses) == numparses, "Not all parses found"
+    if print_trees:
+        for tree in parses:
+            print(tree)
+    else:
+        print("Nr trees:", len(parses))
+    if print_times:
+        print("Time:", t)
+
+
+if __name__ == "__main__":
+    demo()

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

@@ -0,0 +1,129 @@
+# Natural Language Toolkit: evaluation of dependency parser
+#
+# Author: Long Duong <[email protected]>
+#
+# Copyright (C) 2001-2023 NLTK Project
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import unicodedata
+
+
+class DependencyEvaluator:
+    """
+    Class for measuring labelled and unlabelled attachment score for
+    dependency parsing. Note that the evaluation ignores punctuation.
+
+    >>> from nltk.parse import DependencyGraph, DependencyEvaluator
+
+    >>> gold_sent = DependencyGraph(\"""
+    ... Pierre  NNP     2       NMOD
+    ... Vinken  NNP     8       SUB
+    ... ,       ,       2       P
+    ... 61      CD      5       NMOD
+    ... years   NNS     6       AMOD
+    ... old     JJ      2       NMOD
+    ... ,       ,       2       P
+    ... will    MD      0       ROOT
+    ... join    VB      8       VC
+    ... the     DT      11      NMOD
+    ... board   NN      9       OBJ
+    ... as      IN      9       VMOD
+    ... a       DT      15      NMOD
+    ... nonexecutive    JJ      15      NMOD
+    ... director        NN      12      PMOD
+    ... Nov.    NNP     9       VMOD
+    ... 29      CD      16      NMOD
+    ... .       .       9       VMOD
+    ... \""")
+
+    >>> parsed_sent = DependencyGraph(\"""
+    ... Pierre  NNP     8       NMOD
+    ... Vinken  NNP     1       SUB
+    ... ,       ,       3       P
+    ... 61      CD      6       NMOD
+    ... years   NNS     6       AMOD
+    ... old     JJ      2       NMOD
+    ... ,       ,       3       AMOD
+    ... will    MD      0       ROOT
+    ... join    VB      8       VC
+    ... the     DT      11      AMOD
+    ... board   NN      9       OBJECT
+    ... as      IN      9       NMOD
+    ... a       DT      15      NMOD
+    ... nonexecutive    JJ      15      NMOD
+    ... director        NN      12      PMOD
+    ... Nov.    NNP     9       VMOD
+    ... 29      CD      16      NMOD
+    ... .       .       9       VMOD
+    ... \""")
+
+    >>> de = DependencyEvaluator([parsed_sent],[gold_sent])
+    >>> las, uas = de.eval()
+    >>> las
+    0.6
+    >>> uas
+    0.8
+    >>> abs(uas - 0.8) < 0.00001
+    True
+    """
+
+    def __init__(self, parsed_sents, gold_sents):
+        """
+        :param parsed_sents: the list of parsed_sents as the output of parser
+        :type parsed_sents: list(DependencyGraph)
+        """
+        self._parsed_sents = parsed_sents
+        self._gold_sents = gold_sents
+
+    def _remove_punct(self, inStr):
+        """
+        Function to remove punctuation from Unicode string.
+        :param input: the input string
+        :return: Unicode string after remove all punctuation
+        """
+        punc_cat = {"Pc", "Pd", "Ps", "Pe", "Pi", "Pf", "Po"}
+        return "".join(x for x in inStr if unicodedata.category(x) not in punc_cat)
+
+    def eval(self):
+        """
+        Return the Labeled Attachment Score (LAS) and Unlabeled Attachment Score (UAS)
+
+        :return : tuple(float,float)
+        """
+        if len(self._parsed_sents) != len(self._gold_sents):
+            raise ValueError(
+                " Number of parsed sentence is different with number of gold sentence."
+            )
+
+        corr = 0
+        corrL = 0
+        total = 0
+
+        for i in range(len(self._parsed_sents)):
+            parsed_sent_nodes = self._parsed_sents[i].nodes
+            gold_sent_nodes = self._gold_sents[i].nodes
+
+            if len(parsed_sent_nodes) != len(gold_sent_nodes):
+                raise ValueError("Sentences must have equal length.")
+
+            for parsed_node_address, parsed_node in parsed_sent_nodes.items():
+                gold_node = gold_sent_nodes[parsed_node_address]
+
+                if parsed_node["word"] is None:
+                    continue
+                if parsed_node["word"] != gold_node["word"]:
+                    raise ValueError("Sentence sequence is not matched.")
+
+                # Ignore if word is punctuation by default
+                # if (parsed_sent[j]["word"] in string.punctuation):
+                if self._remove_punct(parsed_node["word"]) == "":
+                    continue
+
+                total += 1
+                if parsed_node["head"] == gold_node["head"]:
+                    corr += 1
+                    if parsed_node["rel"] == gold_node["rel"]:
+                        corrL += 1
+
+        return corrL / total, corr / total

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

@@ -0,0 +1,674 @@
+# Natural Language Toolkit: Chart Parser for Feature-Based Grammars
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Rob Speer <[email protected]>
+#         Peter Ljunglöf <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Extension of chart parsing implementation to handle grammars with
+feature structures as nodes.
+"""
+from time import perf_counter
+
+from nltk.featstruct import TYPE, FeatStruct, find_variables, unify
+from nltk.grammar import (
+    CFG,
+    FeatStructNonterminal,
+    Nonterminal,
+    Production,
+    is_nonterminal,
+    is_terminal,
+)
+from nltk.parse.chart import (
+    BottomUpPredictCombineRule,
+    BottomUpPredictRule,
+    CachedTopDownPredictRule,
+    Chart,
+    ChartParser,
+    EdgeI,
+    EmptyPredictRule,
+    FundamentalRule,
+    LeafInitRule,
+    SingleEdgeFundamentalRule,
+    TopDownInitRule,
+    TreeEdge,
+)
+from nltk.sem import logic
+from nltk.tree import Tree
+
+# ////////////////////////////////////////////////////////////
+# Tree Edge
+# ////////////////////////////////////////////////////////////
+
+
+class FeatureTreeEdge(TreeEdge):
+    """
+    A specialized tree edge that allows shared variable bindings
+    between nonterminals on the left-hand side and right-hand side.
+
+    Each ``FeatureTreeEdge`` contains a set of ``bindings``, i.e., a
+    dictionary mapping from variables to values.  If the edge is not
+    complete, then these bindings are simply stored.  However, if the
+    edge is complete, then the constructor applies these bindings to
+    every nonterminal in the edge whose symbol implements the
+    interface ``SubstituteBindingsI``.
+    """
+
+    def __init__(self, span, lhs, rhs, dot=0, bindings=None):
+        """
+        Construct a new edge.  If the edge is incomplete (i.e., if
+        ``dot<len(rhs)``), then store the bindings as-is.  If the edge
+        is complete (i.e., if ``dot==len(rhs)``), then apply the
+        bindings to all nonterminals in ``lhs`` and ``rhs``, and then
+        clear the bindings.  See ``TreeEdge`` for a description of
+        the other arguments.
+        """
+        if bindings is None:
+            bindings = {}
+
+        # If the edge is complete, then substitute in the bindings,
+        # and then throw them away.  (If we didn't throw them away, we
+        # might think that 2 complete edges are different just because
+        # they have different bindings, even though all bindings have
+        # already been applied.)
+        if dot == len(rhs) and bindings:
+            lhs = self._bind(lhs, bindings)
+            rhs = [self._bind(elt, bindings) for elt in rhs]
+            bindings = {}
+
+        # Initialize the edge.
+        TreeEdge.__init__(self, span, lhs, rhs, dot)
+        self._bindings = bindings
+        self._comparison_key = (self._comparison_key, tuple(sorted(bindings.items())))
+
+    @staticmethod
+    def from_production(production, index):
+        """
+        :return: A new ``TreeEdge`` formed from the given production.
+            The new edge's left-hand side and right-hand side will
+            be taken from ``production``; its span will be
+            ``(index,index)``; and its dot position will be ``0``.
+        :rtype: TreeEdge
+        """
+        return FeatureTreeEdge(
+            span=(index, index), lhs=production.lhs(), rhs=production.rhs(), dot=0
+        )
+
+    def move_dot_forward(self, new_end, bindings=None):
+        """
+        :return: A new ``FeatureTreeEdge`` formed from this edge.
+            The new edge's dot position is increased by ``1``,
+            and its end index will be replaced by ``new_end``.
+        :rtype: FeatureTreeEdge
+        :param new_end: The new end index.
+        :type new_end: int
+        :param bindings: Bindings for the new edge.
+        :type bindings: dict
+        """
+        return FeatureTreeEdge(
+            span=(self._span[0], new_end),
+            lhs=self._lhs,
+            rhs=self._rhs,
+            dot=self._dot + 1,
+            bindings=bindings,
+        )
+
+    def _bind(self, nt, bindings):
+        if not isinstance(nt, FeatStructNonterminal):
+            return nt
+        return nt.substitute_bindings(bindings)
+
+    def next_with_bindings(self):
+        return self._bind(self.nextsym(), self._bindings)
+
+    def bindings(self):
+        """
+        Return a copy of this edge's bindings dictionary.
+        """
+        return self._bindings.copy()
+
+    def variables(self):
+        """
+        :return: The set of variables used by this edge.
+        :rtype: set(Variable)
+        """
+        return find_variables(
+            [self._lhs]
+            + list(self._rhs)
+            + list(self._bindings.keys())
+            + list(self._bindings.values()),
+            fs_class=FeatStruct,
+        )
+
+    def __str__(self):
+        if self.is_complete():
+            return super().__str__()
+        else:
+            bindings = "{%s}" % ", ".join(
+                "%s: %r" % item for item in sorted(self._bindings.items())
+            )
+            return f"{super().__str__()} {bindings}"
+
+
+# ////////////////////////////////////////////////////////////
+# A specialized Chart for feature grammars
+# ////////////////////////////////////////////////////////////
+
+# TODO: subsumes check when adding new edges
+
+
+class FeatureChart(Chart):
+    """
+    A Chart for feature grammars.
+    :see: ``Chart`` for more information.
+    """
+
+    def select(self, **restrictions):
+        """
+        Returns an iterator over the edges in this chart.
+        See ``Chart.select`` for more information about the
+        ``restrictions`` on the edges.
+        """
+        # If there are no restrictions, then return all edges.
+        if restrictions == {}:
+            return iter(self._edges)
+
+        # Find the index corresponding to the given restrictions.
+        restr_keys = sorted(restrictions.keys())
+        restr_keys = tuple(restr_keys)
+
+        # If it doesn't exist, then create it.
+        if restr_keys not in self._indexes:
+            self._add_index(restr_keys)
+
+        vals = tuple(
+            self._get_type_if_possible(restrictions[key]) for key in restr_keys
+        )
+        return iter(self._indexes[restr_keys].get(vals, []))
+
+    def _add_index(self, restr_keys):
+        """
+        A helper function for ``select``, which creates a new index for
+        a given set of attributes (aka restriction keys).
+        """
+        # Make sure it's a valid index.
+        for key in restr_keys:
+            if not hasattr(EdgeI, key):
+                raise ValueError("Bad restriction: %s" % key)
+
+        # Create the index.
+        index = self._indexes[restr_keys] = {}
+
+        # Add all existing edges to the index.
+        for edge in self._edges:
+            vals = tuple(
+                self._get_type_if_possible(getattr(edge, key)()) for key in restr_keys
+            )
+            index.setdefault(vals, []).append(edge)
+
+    def _register_with_indexes(self, edge):
+        """
+        A helper function for ``insert``, which registers the new
+        edge with all existing indexes.
+        """
+        for (restr_keys, index) in self._indexes.items():
+            vals = tuple(
+                self._get_type_if_possible(getattr(edge, key)()) for key in restr_keys
+            )
+            index.setdefault(vals, []).append(edge)
+
+    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 item[TYPE]
+        else:
+            return item
+
+    def parses(self, start, tree_class=Tree):
+        for edge in self.select(start=0, end=self._num_leaves):
+            if (
+                (isinstance(edge, FeatureTreeEdge))
+                and (edge.lhs()[TYPE] == start[TYPE])
+                and (unify(edge.lhs(), start, rename_vars=True))
+            ):
+                yield from self.trees(edge, complete=True, tree_class=tree_class)
+
+
+# ////////////////////////////////////////////////////////////
+# Fundamental Rule
+# ////////////////////////////////////////////////////////////
+
+
+class FeatureFundamentalRule(FundamentalRule):
+    r"""
+    A specialized version of the fundamental rule that operates on
+    nonterminals whose symbols are ``FeatStructNonterminal``s.  Rather
+    than simply comparing the nonterminals for equality, they are
+    unified.  Variable bindings from these unifications are collected
+    and stored in the chart using a ``FeatureTreeEdge``.  When a
+    complete edge is generated, these bindings are applied to all
+    nonterminals in the edge.
+
+    The fundamental rule states that:
+
+    - ``[A -> alpha \* B1 beta][i:j]``
+    - ``[B2 -> gamma \*][j:k]``
+
+    licenses the edge:
+
+    - ``[A -> alpha B3 \* beta][i:j]``
+
+    assuming that B1 and B2 can be unified to generate B3.
+    """
+
+    def apply(self, chart, grammar, left_edge, right_edge):
+        # Make sure the rule is applicable.
+        if not (
+            left_edge.end() == right_edge.start()
+            and left_edge.is_incomplete()
+            and right_edge.is_complete()
+            and isinstance(left_edge, FeatureTreeEdge)
+        ):
+            return
+        found = right_edge.lhs()
+        nextsym = left_edge.nextsym()
+        if isinstance(right_edge, FeatureTreeEdge):
+            if not is_nonterminal(nextsym):
+                return
+            if left_edge.nextsym()[TYPE] != right_edge.lhs()[TYPE]:
+                return
+            # Create a copy of the bindings.
+            bindings = left_edge.bindings()
+            # We rename vars here, because we don't want variables
+            # from the two different productions to match.
+            found = found.rename_variables(used_vars=left_edge.variables())
+            # Unify B1 (left_edge.nextsym) with B2 (right_edge.lhs) to
+            # generate B3 (result).
+            result = unify(nextsym, found, bindings, rename_vars=False)
+            if result is None:
+                return
+        else:
+            if nextsym != found:
+                return
+            # Create a copy of the bindings.
+            bindings = left_edge.bindings()
+
+        # Construct the new edge.
+        new_edge = left_edge.move_dot_forward(right_edge.end(), bindings)
+
+        # Add it to the chart, with appropriate child pointers.
+        if chart.insert_with_backpointer(new_edge, left_edge, right_edge):
+            yield new_edge
+
+
+class FeatureSingleEdgeFundamentalRule(SingleEdgeFundamentalRule):
+    """
+    A specialized version of the completer / single edge fundamental rule
+    that operates on nonterminals whose symbols are ``FeatStructNonterminal``.
+    Rather than simply comparing the nonterminals for equality, they are
+    unified.
+    """
+
+    _fundamental_rule = FeatureFundamentalRule()
+
+    def _apply_complete(self, chart, grammar, right_edge):
+        fr = self._fundamental_rule
+        for left_edge in chart.select(
+            end=right_edge.start(), is_complete=False, nextsym=right_edge.lhs()
+        ):
+            yield from fr.apply(chart, grammar, left_edge, right_edge)
+
+    def _apply_incomplete(self, chart, grammar, left_edge):
+        fr = self._fundamental_rule
+        for right_edge in chart.select(
+            start=left_edge.end(), is_complete=True, lhs=left_edge.nextsym()
+        ):
+            yield from fr.apply(chart, grammar, left_edge, right_edge)
+
+
+# ////////////////////////////////////////////////////////////
+# Top-Down Prediction
+# ////////////////////////////////////////////////////////////
+
+
+class FeatureTopDownInitRule(TopDownInitRule):
+    def apply(self, chart, grammar):
+        for prod in grammar.productions(lhs=grammar.start()):
+            new_edge = FeatureTreeEdge.from_production(prod, 0)
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+
+class FeatureTopDownPredictRule(CachedTopDownPredictRule):
+    r"""
+    A specialized version of the (cached) top down predict rule that operates
+    on nonterminals whose symbols are ``FeatStructNonterminal``.  Rather
+    than simply comparing the nonterminals for equality, they are
+    unified.
+
+    The top down expand rule states that:
+
+    - ``[A -> alpha \* B1 beta][i:j]``
+
+    licenses the edge:
+
+    - ``[B2 -> \* gamma][j:j]``
+
+    for each grammar production ``B2 -> gamma``, assuming that B1
+    and B2 can be unified.
+    """
+
+    def apply(self, chart, grammar, edge):
+        if edge.is_complete():
+            return
+        nextsym, index = edge.nextsym(), edge.end()
+        if not is_nonterminal(nextsym):
+            return
+
+        # If we've already applied this rule to an edge with the same
+        # next & end, and the chart & grammar have not changed, then
+        # just return (no new edges to add).
+        nextsym_with_bindings = edge.next_with_bindings()
+        done = self._done.get((nextsym_with_bindings, index), (None, None))
+        if done[0] is chart and done[1] is grammar:
+            return
+
+        for prod in grammar.productions(lhs=nextsym):
+            # If the left corner in the predicted production is
+            # leaf, it must match with the input.
+            if prod.rhs():
+                first = prod.rhs()[0]
+                if is_terminal(first):
+                    if index >= chart.num_leaves():
+                        continue
+                    if first != chart.leaf(index):
+                        continue
+
+            # We rename vars here, because we don't want variables
+            # from the two different productions to match.
+            if unify(prod.lhs(), nextsym_with_bindings, rename_vars=True):
+                new_edge = FeatureTreeEdge.from_production(prod, edge.end())
+                if chart.insert(new_edge, ()):
+                    yield new_edge
+
+        # Record the fact that we've applied this rule.
+        self._done[nextsym_with_bindings, index] = (chart, grammar)
+
+
+# ////////////////////////////////////////////////////////////
+# Bottom-Up Prediction
+# ////////////////////////////////////////////////////////////
+
+
+class FeatureBottomUpPredictRule(BottomUpPredictRule):
+    def apply(self, chart, grammar, edge):
+        if edge.is_incomplete():
+            return
+        for prod in grammar.productions(rhs=edge.lhs()):
+            if isinstance(edge, FeatureTreeEdge):
+                _next = prod.rhs()[0]
+                if not is_nonterminal(_next):
+                    continue
+
+            new_edge = FeatureTreeEdge.from_production(prod, edge.start())
+            if chart.insert(new_edge, ()):
+                yield new_edge
+
+
+class FeatureBottomUpPredictCombineRule(BottomUpPredictCombineRule):
+    def apply(self, chart, grammar, edge):
+        if edge.is_incomplete():
+            return
+        found = edge.lhs()
+        for prod in grammar.productions(rhs=found):
+            bindings = {}
+            if isinstance(edge, FeatureTreeEdge):
+                _next = prod.rhs()[0]
+                if not is_nonterminal(_next):
+                    continue
+
+                # We rename vars here, because we don't want variables
+                # from the two different productions to match.
+                used_vars = find_variables(
+                    (prod.lhs(),) + prod.rhs(), fs_class=FeatStruct
+                )
+                found = found.rename_variables(used_vars=used_vars)
+
+                result = unify(_next, found, bindings, rename_vars=False)
+                if result is None:
+                    continue
+
+            new_edge = FeatureTreeEdge.from_production(
+                prod, edge.start()
+            ).move_dot_forward(edge.end(), bindings)
+            if chart.insert(new_edge, (edge,)):
+                yield new_edge
+
+
+class FeatureEmptyPredictRule(EmptyPredictRule):
+    def apply(self, chart, grammar):
+        for prod in grammar.productions(empty=True):
+            for index in range(chart.num_leaves() + 1):
+                new_edge = FeatureTreeEdge.from_production(prod, index)
+                if chart.insert(new_edge, ()):
+                    yield new_edge
+
+
+# ////////////////////////////////////////////////////////////
+# Feature Chart Parser
+# ////////////////////////////////////////////////////////////
+
+TD_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureTopDownInitRule(),
+    FeatureTopDownPredictRule(),
+    FeatureSingleEdgeFundamentalRule(),
+]
+BU_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureEmptyPredictRule(),
+    FeatureBottomUpPredictRule(),
+    FeatureSingleEdgeFundamentalRule(),
+]
+BU_LC_FEATURE_STRATEGY = [
+    LeafInitRule(),
+    FeatureEmptyPredictRule(),
+    FeatureBottomUpPredictCombineRule(),
+    FeatureSingleEdgeFundamentalRule(),
+]
+
+
+class FeatureChartParser(ChartParser):
+    def __init__(
+        self,
+        grammar,
+        strategy=BU_LC_FEATURE_STRATEGY,
+        trace_chart_width=20,
+        chart_class=FeatureChart,
+        **parser_args,
+    ):
+        ChartParser.__init__(
+            self,
+            grammar,
+            strategy=strategy,
+            trace_chart_width=trace_chart_width,
+            chart_class=chart_class,
+            **parser_args,
+        )
+
+
+class FeatureTopDownChartParser(FeatureChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureChartParser.__init__(self, grammar, TD_FEATURE_STRATEGY, **parser_args)
+
+
+class FeatureBottomUpChartParser(FeatureChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureChartParser.__init__(self, grammar, BU_FEATURE_STRATEGY, **parser_args)
+
+
+class FeatureBottomUpLeftCornerChartParser(FeatureChartParser):
+    def __init__(self, grammar, **parser_args):
+        FeatureChartParser.__init__(
+            self, grammar, BU_LC_FEATURE_STRATEGY, **parser_args
+        )
+
+
+# ////////////////////////////////////////////////////////////
+# Instantiate Variable Chart
+# ////////////////////////////////////////////////////////////
+
+
+class InstantiateVarsChart(FeatureChart):
+    """
+    A specialized chart that 'instantiates' variables whose names
+    start with '@', by replacing them with unique new variables.
+    In particular, whenever a complete edge is added to the chart, any
+    variables in the edge's ``lhs`` whose names start with '@' will be
+    replaced by unique new ``Variable``.
+    """
+
+    def __init__(self, tokens):
+        FeatureChart.__init__(self, tokens)
+
+    def initialize(self):
+        self._instantiated = set()
+        FeatureChart.initialize(self)
+
+    def insert(self, edge, child_pointer_list):
+        if edge in self._instantiated:
+            return False
+        self.instantiate_edge(edge)
+        return FeatureChart.insert(self, edge, child_pointer_list)
+
+    def instantiate_edge(self, edge):
+        """
+        If the edge is a ``FeatureTreeEdge``, and it is complete,
+        then instantiate all variables whose names start with '@',
+        by replacing them with unique new variables.
+
+        Note that instantiation is done in-place, since the
+        parsing algorithms might already hold a reference to
+        the edge for future use.
+        """
+        # If the edge is a leaf, or is not complete, or is
+        # already in the chart, then just return it as-is.
+        if not isinstance(edge, FeatureTreeEdge):
+            return
+        if not edge.is_complete():
+            return
+        if edge in self._edge_to_cpls:
+            return
+
+        # Get a list of variables that need to be instantiated.
+        # If there are none, then return as-is.
+        inst_vars = self.inst_vars(edge)
+        if not inst_vars:
+            return
+
+        # Instantiate the edge!
+        self._instantiated.add(edge)
+        edge._lhs = edge.lhs().substitute_bindings(inst_vars)
+
+    def inst_vars(self, edge):
+        return {
+            var: logic.unique_variable()
+            for var in edge.lhs().variables()
+            if var.name.startswith("@")
+        }
+
+
+# ////////////////////////////////////////////////////////////
+# Demo
+# ////////////////////////////////////////////////////////////
+
+
+def demo_grammar():
+    from nltk.grammar import FeatureGrammar
+
+    return FeatureGrammar.fromstring(
+        """
+S  -> NP VP
+PP -> Prep NP
+NP -> NP PP
+VP -> VP PP
+VP -> Verb NP
+VP -> Verb
+NP -> Det[pl=?x] Noun[pl=?x]
+NP -> "John"
+NP -> "I"
+Det -> "the"
+Det -> "my"
+Det[-pl] -> "a"
+Noun[-pl] -> "dog"
+Noun[-pl] -> "cookie"
+Verb -> "ate"
+Verb -> "saw"
+Prep -> "with"
+Prep -> "under"
+"""
+    )
+
+
+def demo(
+    print_times=True,
+    print_grammar=True,
+    print_trees=True,
+    print_sentence=True,
+    trace=1,
+    parser=FeatureChartParser,
+    sent="I saw John with a dog with my cookie",
+):
+    import sys
+    import time
+
+    print()
+    grammar = demo_grammar()
+    if print_grammar:
+        print(grammar)
+        print()
+    print("*", parser.__name__)
+    if print_sentence:
+        print("Sentence:", sent)
+    tokens = sent.split()
+    t = perf_counter()
+    cp = parser(grammar, trace=trace)
+    chart = cp.chart_parse(tokens)
+    trees = list(chart.parses(grammar.start()))
+    if print_times:
+        print("Time: %s" % (perf_counter() - t))
+    if print_trees:
+        for tree in trees:
+            print(tree)
+    else:
+        print("Nr trees:", len(trees))
+
+
+def run_profile():
+    import profile
+
+    profile.run("for i in range(1): demo()", "/tmp/profile.out")
+    import pstats
+
+    p = pstats.Stats("/tmp/profile.out")
+    p.strip_dirs().sort_stats("time", "cum").print_stats(60)
+    p.strip_dirs().sort_stats("cum", "time").print_stats(60)
+
+
+if __name__ == "__main__":
+    from nltk.data import load
+
+    demo()
+    print()
+    grammar = load("grammars/book_grammars/feat0.fcfg")
+    cp = FeatureChartParser(grammar, trace=2)
+    sent = "Kim likes children"
+    tokens = sent.split()
+    trees = cp.parse(tokens)
+    for tree in trees:
+        print(tree)

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

@@ -0,0 +1,85 @@
+# Natural Language Toolkit: Generating from a CFG
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Steven Bird <[email protected]>
+#         Peter Ljunglöf <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+import itertools
+import sys
+
+from nltk.grammar import Nonterminal
+
+
+def generate(grammar, start=None, depth=None, n=None):
+    """
+    Generates an iterator of all sentences from a CFG.
+
+    :param grammar: The Grammar used to generate sentences.
+    :param start: The Nonterminal from which to start generate sentences.
+    :param depth: The maximal depth of the generated tree.
+    :param n: The maximum number of sentences to return.
+    :return: An iterator of lists of terminal tokens.
+    """
+    if not start:
+        start = grammar.start()
+    if depth is None:
+        depth = sys.maxsize
+
+    iter = _generate_all(grammar, [start], depth)
+
+    if n:
+        iter = itertools.islice(iter, n)
+
+    return iter
+
+
+def _generate_all(grammar, items, depth):
+    if items:
+        try:
+            for frag1 in _generate_one(grammar, items[0], depth):
+                for frag2 in _generate_all(grammar, items[1:], depth):
+                    yield frag1 + frag2
+        except RecursionError as error:
+            # Helpful error message while still showing the recursion stack.
+            raise RuntimeError(
+                "The grammar has rule(s) that yield infinite recursion!"
+            ) from error
+    else:
+        yield []
+
+
+def _generate_one(grammar, item, depth):
+    if depth > 0:
+        if isinstance(item, Nonterminal):
+            for prod in grammar.productions(lhs=item):
+                yield from _generate_all(grammar, prod.rhs(), depth - 1)
+        else:
+            yield [item]
+
+
+demo_grammar = """
+  S -> NP VP
+  NP -> Det N
+  PP -> P NP
+  VP -> 'slept' | 'saw' NP | 'walked' PP
+  Det -> 'the' | 'a'
+  N -> 'man' | 'park' | 'dog'
+  P -> 'in' | 'with'
+"""
+
+
+def demo(N=23):
+    from nltk.grammar import CFG
+
+    print("Generating the first %d sentences for demo grammar:" % (N,))
+    print(demo_grammar)
+    grammar = CFG.fromstring(demo_grammar)
+    for n, sent in enumerate(generate(grammar, n=N), 1):
+        print("%3d. %s" % (n, " ".join(sent)))
+
+
+if __name__ == "__main__":
+    demo()

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

@@ -0,0 +1,479 @@
+# Natural Language Toolkit: Shift-Reduce Parser
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Edward Loper <[email protected]>
+#         Steven Bird <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+from nltk.grammar import Nonterminal
+from nltk.parse.api import ParserI
+from nltk.tree import Tree
+
+
+##//////////////////////////////////////////////////////
+##  Shift/Reduce Parser
+##//////////////////////////////////////////////////////
+class ShiftReduceParser(ParserI):
+    """
+    A simple bottom-up CFG parser that uses two operations, "shift"
+    and "reduce", to find a single parse for a text.
+
+    ``ShiftReduceParser`` maintains a stack, which records the
+    structure of a portion of the text.  This stack is a list of
+    strings and Trees that collectively cover a portion of
+    the text.  For example, while parsing the sentence "the dog saw
+    the man" with a typical grammar, ``ShiftReduceParser`` will produce
+    the following stack, which covers "the dog saw"::
+
+       [(NP: (Det: 'the') (N: 'dog')), (V: 'saw')]
+
+    ``ShiftReduceParser`` attempts to extend the stack to cover the
+    entire text, and to combine the stack elements into a single tree,
+    producing a complete parse for the sentence.
+
+    Initially, the stack is empty.  It is extended to cover the text,
+    from left to right, by repeatedly applying two operations:
+
+      - "shift" moves a token from the beginning of the text to the
+        end of the stack.
+      - "reduce" uses a CFG production to combine the rightmost stack
+        elements into a single Tree.
+
+    Often, more than one operation can be performed on a given stack.
+    In this case, ``ShiftReduceParser`` uses the following heuristics
+    to decide which operation to perform:
+
+      - Only shift if no reductions are available.
+      - If multiple reductions are available, then apply the reduction
+        whose CFG production is listed earliest in the grammar.
+
+    Note that these heuristics are not guaranteed to choose an
+    operation that leads to a parse of the text.  Also, if multiple
+    parses exists, ``ShiftReduceParser`` will return at most one of
+    them.
+
+    :see: ``nltk.grammar``
+    """
+
+    def __init__(self, grammar, trace=0):
+        """
+        Create a new ``ShiftReduceParser``, that uses ``grammar`` to
+        parse texts.
+
+        :type grammar: Grammar
+        :param grammar: The grammar used to parse texts.
+        :type trace: int
+        :param trace: The level of tracing that should be used when
+            parsing a text.  ``0`` will generate no tracing output;
+            and higher numbers will produce more verbose tracing
+            output.
+        """
+        self._grammar = grammar
+        self._trace = trace
+        self._check_grammar()
+
+    def grammar(self):
+        return self._grammar
+
+    def parse(self, tokens):
+        tokens = list(tokens)
+        self._grammar.check_coverage(tokens)
+
+        # initialize the stack.
+        stack = []
+        remaining_text = tokens
+
+        # Trace output.
+        if self._trace:
+            print("Parsing %r" % " ".join(tokens))
+            self._trace_stack(stack, remaining_text)
+
+        # iterate through the text, pushing the token onto
+        # the stack, then reducing the stack.
+        while len(remaining_text) > 0:
+            self._shift(stack, remaining_text)
+            while self._reduce(stack, remaining_text):
+                pass
+
+        # Did we reduce everything?
+        if len(stack) == 1:
+            # Did we end up with the right category?
+            if stack[0].label() == self._grammar.start().symbol():
+                yield stack[0]
+
+    def _shift(self, stack, remaining_text):
+        """
+        Move a token from the beginning of ``remaining_text`` to the
+        end of ``stack``.
+
+        :type stack: list(str and Tree)
+        :param stack: A list of strings and Trees, encoding
+            the structure of the text that has been parsed so far.
+        :type remaining_text: list(str)
+        :param remaining_text: The portion of the text that is not yet
+            covered by ``stack``.
+        :rtype: None
+        """
+        stack.append(remaining_text[0])
+        remaining_text.remove(remaining_text[0])
+        if self._trace:
+            self._trace_shift(stack, remaining_text)
+
+    def _match_rhs(self, rhs, rightmost_stack):
+        """
+        :rtype: bool
+        :return: true if the right hand side of a CFG production
+            matches the rightmost elements of the stack.  ``rhs``
+            matches ``rightmost_stack`` if they are the same length,
+            and each element of ``rhs`` matches the corresponding
+            element of ``rightmost_stack``.  A nonterminal element of
+            ``rhs`` matches any Tree whose node value is equal
+            to the nonterminal's symbol.  A terminal element of ``rhs``
+            matches any string whose type is equal to the terminal.
+        :type rhs: list(terminal and Nonterminal)
+        :param rhs: The right hand side of a CFG production.
+        :type rightmost_stack: list(string and Tree)
+        :param rightmost_stack: The rightmost elements of the parser's
+            stack.
+        """
+
+        if len(rightmost_stack) != len(rhs):
+            return False
+        for i in range(len(rightmost_stack)):
+            if isinstance(rightmost_stack[i], Tree):
+                if not isinstance(rhs[i], Nonterminal):
+                    return False
+                if rightmost_stack[i].label() != rhs[i].symbol():
+                    return False
+            else:
+                if isinstance(rhs[i], Nonterminal):
+                    return False
+                if rightmost_stack[i] != rhs[i]:
+                    return False
+        return True
+
+    def _reduce(self, stack, remaining_text, production=None):
+        """
+        Find a CFG production whose right hand side matches the
+        rightmost stack elements; and combine those stack elements
+        into a single Tree, with the node specified by the
+        production's left-hand side.  If more than one CFG production
+        matches the stack, then use the production that is listed
+        earliest in the grammar.  The new Tree replaces the
+        elements in the stack.
+
+        :rtype: Production or None
+        :return: If a reduction is performed, then return the CFG
+            production that the reduction is based on; otherwise,
+            return false.
+        :type stack: list(string and Tree)
+        :param stack: A list of strings and Trees, encoding
+            the structure of the text that has been parsed so far.
+        :type remaining_text: list(str)
+        :param remaining_text: The portion of the text that is not yet
+            covered by ``stack``.
+        """
+        if production is None:
+            productions = self._grammar.productions()
+        else:
+            productions = [production]
+
+        # Try each production, in order.
+        for production in productions:
+            rhslen = len(production.rhs())
+
+            # check if the RHS of a production matches the top of the stack
+            if self._match_rhs(production.rhs(), stack[-rhslen:]):
+
+                # combine the tree to reflect the reduction
+                tree = Tree(production.lhs().symbol(), stack[-rhslen:])
+                stack[-rhslen:] = [tree]
+
+                # We reduced something
+                if self._trace:
+                    self._trace_reduce(stack, production, remaining_text)
+                return production
+
+        # We didn't reduce anything
+        return None
+
+    def trace(self, trace=2):
+        """
+        Set the level of tracing output that should be generated when
+        parsing a text.
+
+        :type trace: int
+        :param trace: The trace level.  A trace level of ``0`` will
+            generate no tracing output; and higher trace levels will
+            produce more verbose tracing output.
+        :rtype: None
+        """
+        # 1: just show shifts.
+        # 2: show shifts & reduces
+        # 3: display which tokens & productions are shifed/reduced
+        self._trace = trace
+
+    def _trace_stack(self, stack, remaining_text, marker=" "):
+        """
+        Print trace output displaying the given stack and text.
+
+        :rtype: None
+        :param marker: A character that is printed to the left of the
+            stack.  This is used with trace level 2 to print 'S'
+            before shifted stacks and 'R' before reduced stacks.
+        """
+        s = "  " + marker + " [ "
+        for elt in stack:
+            if isinstance(elt, Tree):
+                s += repr(Nonterminal(elt.label())) + " "
+            else:
+                s += repr(elt) + " "
+        s += "* " + " ".join(remaining_text) + "]"
+        print(s)
+
+    def _trace_shift(self, stack, remaining_text):
+        """
+        Print trace output displaying that a token has been shifted.
+
+        :rtype: None
+        """
+        if self._trace > 2:
+            print("Shift %r:" % stack[-1])
+        if self._trace == 2:
+            self._trace_stack(stack, remaining_text, "S")
+        elif self._trace > 0:
+            self._trace_stack(stack, remaining_text)
+
+    def _trace_reduce(self, stack, production, remaining_text):
+        """
+        Print trace output displaying that ``production`` was used to
+        reduce ``stack``.
+
+        :rtype: None
+        """
+        if self._trace > 2:
+            rhs = " ".join(production.rhs())
+            print(f"Reduce {production.lhs()!r} <- {rhs}")
+        if self._trace == 2:
+            self._trace_stack(stack, remaining_text, "R")
+        elif self._trace > 1:
+            self._trace_stack(stack, remaining_text)
+
+    def _check_grammar(self):
+        """
+        Check to make sure that all of the CFG productions are
+        potentially useful.  If any productions can never be used,
+        then print a warning.
+
+        :rtype: None
+        """
+        productions = self._grammar.productions()
+
+        # Any production whose RHS is an extension of another production's RHS
+        # will never be used.
+        for i in range(len(productions)):
+            for j in range(i + 1, len(productions)):
+                rhs1 = productions[i].rhs()
+                rhs2 = productions[j].rhs()
+                if rhs1[: len(rhs2)] == rhs2:
+                    print("Warning: %r will never be used" % productions[i])
+
+
+##//////////////////////////////////////////////////////
+##  Stepping Shift/Reduce Parser
+##//////////////////////////////////////////////////////
+class SteppingShiftReduceParser(ShiftReduceParser):
+    """
+    A ``ShiftReduceParser`` that allows you to setp through the parsing
+    process, performing a single operation at a time.  It also allows
+    you to change the parser's grammar midway through parsing a text.
+
+    The ``initialize`` method is used to start parsing a text.
+    ``shift`` performs a single shift operation, and ``reduce`` performs
+    a single reduce operation.  ``step`` will perform a single reduce
+    operation if possible; otherwise, it will perform a single shift
+    operation.  ``parses`` returns the set of parses that have been
+    found by the parser.
+
+    :ivar _history: A list of ``(stack, remaining_text)`` pairs,
+        containing all of the previous states of the parser.  This
+        history is used to implement the ``undo`` operation.
+    :see: ``nltk.grammar``
+    """
+
+    def __init__(self, grammar, trace=0):
+        super().__init__(grammar, trace)
+        self._stack = None
+        self._remaining_text = None
+        self._history = []
+
+    def parse(self, tokens):
+        tokens = list(tokens)
+        self.initialize(tokens)
+        while self.step():
+            pass
+        return self.parses()
+
+    def stack(self):
+        """
+        :return: The parser's stack.
+        :rtype: list(str and Tree)
+        """
+        return self._stack
+
+    def remaining_text(self):
+        """
+        :return: The portion of the text that is not yet covered by the
+            stack.
+        :rtype: list(str)
+        """
+        return self._remaining_text
+
+    def initialize(self, tokens):
+        """
+        Start parsing a given text.  This sets the parser's stack to
+        ``[]`` and sets its remaining text to ``tokens``.
+        """
+        self._stack = []
+        self._remaining_text = tokens
+        self._history = []
+
+    def step(self):
+        """
+        Perform a single parsing operation.  If a reduction is
+        possible, then perform that reduction, and return the
+        production that it is based on.  Otherwise, if a shift is
+        possible, then perform it, and return True.  Otherwise,
+        return False.
+
+        :return: False if no operation was performed; True if a shift was
+            performed; and the CFG production used to reduce if a
+            reduction was performed.
+        :rtype: Production or bool
+        """
+        return self.reduce() or self.shift()
+
+    def shift(self):
+        """
+        Move a token from the beginning of the remaining text to the
+        end of the stack.  If there are no more tokens in the
+        remaining text, then do nothing.
+
+        :return: True if the shift operation was successful.
+        :rtype: bool
+        """
+        if len(self._remaining_text) == 0:
+            return False
+        self._history.append((self._stack[:], self._remaining_text[:]))
+        self._shift(self._stack, self._remaining_text)
+        return True
+
+    def reduce(self, production=None):
+        """
+        Use ``production`` to combine the rightmost stack elements into
+        a single Tree.  If ``production`` does not match the
+        rightmost stack elements, then do nothing.
+
+        :return: The production used to reduce the stack, if a
+            reduction was performed.  If no reduction was performed,
+            return None.
+
+        :rtype: Production or None
+        """
+        self._history.append((self._stack[:], self._remaining_text[:]))
+        return_val = self._reduce(self._stack, self._remaining_text, production)
+
+        if not return_val:
+            self._history.pop()
+        return return_val
+
+    def undo(self):
+        """
+        Return the parser to its state before the most recent
+        shift or reduce operation.  Calling ``undo`` repeatedly return
+        the parser to successively earlier states.  If no shift or
+        reduce operations have been performed, ``undo`` will make no
+        changes.
+
+        :return: true if an operation was successfully undone.
+        :rtype: bool
+        """
+        if len(self._history) == 0:
+            return False
+        (self._stack, self._remaining_text) = self._history.pop()
+        return True
+
+    def reducible_productions(self):
+        """
+        :return: A list of the productions for which reductions are
+            available for the current parser state.
+        :rtype: list(Production)
+        """
+        productions = []
+        for production in self._grammar.productions():
+            rhslen = len(production.rhs())
+            if self._match_rhs(production.rhs(), self._stack[-rhslen:]):
+                productions.append(production)
+        return productions
+
+    def parses(self):
+        """
+        :return: An iterator of the parses that have been found by this
+            parser so far.
+        :rtype: iter(Tree)
+        """
+        if (
+            len(self._remaining_text) == 0
+            and len(self._stack) == 1
+            and self._stack[0].label() == self._grammar.start().symbol()
+        ):
+            yield self._stack[0]
+
+    # copied from nltk.parser
+
+    def set_grammar(self, grammar):
+        """
+        Change the grammar used to parse texts.
+
+        :param grammar: The new grammar.
+        :type grammar: CFG
+        """
+        self._grammar = grammar
+
+
+##//////////////////////////////////////////////////////
+##  Demonstration Code
+##//////////////////////////////////////////////////////
+
+
+def demo():
+    """
+    A demonstration of the shift-reduce parser.
+    """
+
+    from nltk import CFG, parse
+
+    grammar = CFG.fromstring(
+        """
+    S -> NP VP
+    NP -> Det N | Det N PP
+    VP -> V NP | V NP PP
+    PP -> P NP
+    NP -> 'I'
+    N -> 'man' | 'park' | 'telescope' | 'dog'
+    Det -> 'the' | 'a'
+    P -> 'in' | 'with'
+    V -> 'saw'
+    """
+    )
+
+    sent = "I saw a man in the park".split()
+
+    parser = parse.ShiftReduceParser(grammar, trace=2)
+    for p in parser.parse(sent):
+        print(p)
+
+
+if __name__ == "__main__":
+    demo()