nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/parse/__init__.py

@@ -1,80 +1,81 @@
-# Natural Language Toolkit: Parsers
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Steven Bird <stevenbird1@gmail.com>
-#         Edward Loper <edloper@gmail.com>
-# URL: <http://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.chart import (ChartParser, SteppingChartParser, TopDownChartParser,
-                              BottomUpChartParser, BottomUpLeftCornerChartParser,
-                              LeftCornerChartParser)
-from nltk.parse.featurechart import (FeatureChartParser, FeatureTopDownChartParser,
-                                     FeatureBottomUpChartParser,
-                                     FeatureBottomUpLeftCornerChartParser)
-from nltk.parse.earleychart import (IncrementalChartParser, EarleyChartParser,
-                                    IncrementalTopDownChartParser,
-                                    IncrementalBottomUpChartParser,
-                                    IncrementalBottomUpLeftCornerChartParser,
-                                    IncrementalLeftCornerChartParser,
-                                    FeatureIncrementalChartParser,
-                                    FeatureEarleyChartParser,
-                                    FeatureIncrementalTopDownChartParser,
-                                    FeatureIncrementalBottomUpChartParser,
-                                    FeatureIncrementalBottomUpLeftCornerChartParser)
-from nltk.parse.pchart import (BottomUpProbabilisticChartParser, InsideChartParser,
-                               RandomChartParser, UnsortedChartParser,
-                               LongestChartParser)
-from nltk.parse.recursivedescent import (RecursiveDescentParser,
-                                         SteppingRecursiveDescentParser)
-from nltk.parse.shiftreduce import (ShiftReduceParser, SteppingShiftReduceParser)
-from nltk.parse.util import load_parser, TestGrammar, extract_test_sentences
-from nltk.parse.viterbi import ViterbiParser
-from nltk.parse.dependencygraph import DependencyGraph
-from nltk.parse.projectivedependencyparser import (ProjectiveDependencyParser,
-                                                   ProbabilisticProjectiveDependencyParser)
-from nltk.parse.nonprojectivedependencyparser import (NonprojectiveDependencyParser,
-                                                      NaiveBayesDependencyScorer,
-                                                      ProbabilisticNonprojectiveParser)
-from nltk.parse.malt import MaltParser
-from nltk.parse.evaluate import DependencyEvaluator
-from nltk.parse.transitionparser import TransitionParser
-from nltk.parse.bllip import BllipParser
+# Natural Language Toolkit: Parsers
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+#         Edward Loper <edloper@gmail.com>
+# URL: <http://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.chart import (ChartParser, SteppingChartParser, TopDownChartParser,
+                              BottomUpChartParser, BottomUpLeftCornerChartParser,
+                              LeftCornerChartParser)
+from nltk.parse.featurechart import (FeatureChartParser, FeatureTopDownChartParser,
+                                     FeatureBottomUpChartParser,
+                                     FeatureBottomUpLeftCornerChartParser)
+from nltk.parse.earleychart import (IncrementalChartParser, EarleyChartParser,
+                                    IncrementalTopDownChartParser,
+                                    IncrementalBottomUpChartParser,
+                                    IncrementalBottomUpLeftCornerChartParser,
+                                    IncrementalLeftCornerChartParser,
+                                    FeatureIncrementalChartParser,
+                                    FeatureEarleyChartParser,
+                                    FeatureIncrementalTopDownChartParser,
+                                    FeatureIncrementalBottomUpChartParser,
+                                    FeatureIncrementalBottomUpLeftCornerChartParser)
+from nltk.parse.pchart import (BottomUpProbabilisticChartParser, InsideChartParser,
+                               RandomChartParser, UnsortedChartParser,
+                               LongestChartParser)
+from nltk.parse.recursivedescent import (RecursiveDescentParser,
+                                         SteppingRecursiveDescentParser)
+from nltk.parse.shiftreduce import (ShiftReduceParser, SteppingShiftReduceParser)
+from nltk.parse.util import load_parser, TestGrammar, extract_test_sentences
+from nltk.parse.viterbi import ViterbiParser
+from nltk.parse.dependencygraph import DependencyGraph
+from nltk.parse.projectivedependencyparser import (ProjectiveDependencyParser,
+                                                   ProbabilisticProjectiveDependencyParser)
+from nltk.parse.nonprojectivedependencyparser import (NonprojectiveDependencyParser,
+                                                      NaiveBayesDependencyScorer,
+                                                      ProbabilisticNonprojectiveParser)
+from nltk.parse.malt import MaltParser
+from nltk.parse.evaluate import DependencyEvaluator
+from nltk.parse.transitionparser import TransitionParser
+from nltk.parse.bllip import BllipParser
+from nltk.parse.corenlp import CoreNLPParser, CoreNLPDependencyParser

{nltk-3.2 → nltk-3.3}/nltk/parse/api.py

@@ -1,66 +1,66 @@
-# Natural Language Toolkit: Parser API
-#
-# Copyright (C) 2001-2015 NLTK Project
-# Author: Steven Bird <stevenbird1@gmail.com>
-#         Edward Loper <edloper@gmail.com>
-# URL: <http://nltk.org/>
-# For license information, see LICENSE.TXT
-#
-
-import itertools
-
-from nltk.internals import overridden
-
-class ParserI(object):
-    """
-    A processing class for deriving trees that represent possible
-    structures for a sequence of tokens.  These tree structures are
-    known as "parses".  Typically, parsers are used to derive syntax
-    trees for sentences.  But parsers can also be used to derive other
-    kinds of tree structure, such as morphological trees and discourse
-    structures.
-
-    Subclasses must define:
-      - at least one of: ``parse()``, ``parse_sents()``.
-
-    Subclasses may define:
-      - ``grammar()``
-    """
-    def grammar(self):
-        """
-        :return: The grammar used by this parser.
-        """
-        raise NotImplementedError()
-
-    def parse(self, sent, *args, **kwargs):
-        """
-        :return: An iterator that generates parse trees for the sentence.
-        When possible this list is sorted from most likely to least likely.
-
-        :param sent: The sentence to be parsed
-        :type sent: list(str)
-        :rtype: iter(Tree)
-        """
-        if overridden(self.parse_sents):
-            return next(self.parse_sents([sent], *args, **kwargs))
-        elif overridden(self.parse_one):
-            return (tree for tree in [self.parse_one(sent, *args, **kwargs)] if tree is not None)
-        elif overridden(self.parse_all):
-            return iter(self.parse_all(sent, *args, **kwargs))
-        else:
-            raise NotImplementedError()
-
-    def parse_sents(self, sents, *args, **kwargs):
-        """
-        Apply ``self.parse()`` to each element of ``sents``.
-        :rtype: iter(iter(Tree))
-        """
-        return (self.parse(sent, *args, **kwargs) for sent in sents)
-
-    def parse_all(self, sent, *args, **kwargs):
-        """:rtype: list(Tree)"""
-        return list(self.parse(sent, *args, **kwargs))
-
-    def parse_one(self, sent, *args, **kwargs):
-        """:rtype: Tree or None"""
-        return next(self.parse(sent, *args, **kwargs), None)
+# Natural Language Toolkit: Parser API
+#
+# Copyright (C) 2001-2018 NLTK Project
+# Author: Steven Bird <stevenbird1@gmail.com>
+#         Edward Loper <edloper@gmail.com>
+# URL: <http://nltk.org/>
+# For license information, see LICENSE.TXT
+#
+
+import itertools
+
+from nltk.internals import overridden
+
+class ParserI(object):
+    """
+    A processing class for deriving trees that represent possible
+    structures for a sequence of tokens.  These tree structures are
+    known as "parses".  Typically, parsers are used to derive syntax
+    trees for sentences.  But parsers can also be used to derive other
+    kinds of tree structure, such as morphological trees and discourse
+    structures.
+
+    Subclasses must define:
+      - at least one of: ``parse()``, ``parse_sents()``.
+
+    Subclasses may define:
+      - ``grammar()``
+    """
+    def grammar(self):
+        """
+        :return: The grammar used by this parser.
+        """
+        raise NotImplementedError()
+
+    def parse(self, sent, *args, **kwargs):
+        """
+        :return: An iterator that generates parse trees for the sentence.
+        When possible this list is sorted from most likely to least likely.
+
+        :param sent: The sentence to be parsed
+        :type sent: list(str)
+        :rtype: iter(Tree)
+        """
+        if overridden(self.parse_sents):
+            return next(self.parse_sents([sent], *args, **kwargs))
+        elif overridden(self.parse_one):
+            return (tree for tree in [self.parse_one(sent, *args, **kwargs)] if tree is not None)
+        elif overridden(self.parse_all):
+            return iter(self.parse_all(sent, *args, **kwargs))
+        else:
+            raise NotImplementedError()
+
+    def parse_sents(self, sents, *args, **kwargs):
+        """
+        Apply ``self.parse()`` to each element of ``sents``.
+        :rtype: iter(iter(Tree))
+        """
+        return (self.parse(sent, *args, **kwargs) for sent in sents)
+
+    def parse_all(self, sent, *args, **kwargs):
+        """:rtype: list(Tree)"""
+        return list(self.parse(sent, *args, **kwargs))
+
+    def parse_one(self, sent, *args, **kwargs):
+        """:rtype: Tree or None"""
+        return next(self.parse(sent, *args, **kwargs), None)