nltk 3.2__zip → 3.3__zip

{nltk-3.2 → nltk-3.3}/nltk/test/inference_fixt.py

@@ -1,11 +1,12 @@
-# -*- coding: utf-8 -*-
-from __future__ import absolute_import
-
-def setup_module(module):
-    from nose import SkipTest
-    from nltk.inference.mace import Mace
-    try:
-        m = Mace()
-        m._find_binary('mace4')
-    except LookupError:
-        raise SkipTest("Mace4/Prover9 is not available so inference.doctest was skipped")
+# -*- coding: utf-8 -*-
+from __future__ import absolute_import
+
+
+def setup_module(module):
+    from nose import SkipTest
+    from nltk.inference.mace import Mace
+    try:
+        m = Mace()
+        m._find_binary('mace4')
+    except LookupError:
+        raise SkipTest("Mace4/Prover9 is not available so inference.doctest was skipped")

{nltk-3.2 → nltk-3.3}/nltk/test/internals.doctest

@@ -1,140 +1,140 @@
-.. Copyright (C) 2001-2015 NLTK Project
-.. For license information, see LICENSE.TXT
-
-==========================================
- Unit tests for the nltk.utilities module
-==========================================
-
-overridden()
-~~~~~~~~~~~~
-    >>> from nltk.internals import overridden
-
-The typical use case is in defining methods for an interface or
-abstract base class, in such a way that subclasses don't have to
-implement all of the methods:
-
-    >>> class EaterI(object):
-    ...     '''Subclass must define eat() or batch_eat().'''
-    ...     def eat(self, food):
-    ...         if overridden(self.batch_eat):
-    ...             return self.batch_eat([food])[0]
-    ...         else:
-    ...             raise NotImplementedError()
-    ...     def batch_eat(self, foods):
-    ...         return [self.eat(food) for food in foods]
-
-As long as a subclass implements one method, it will be used to
-perform the other method:
-
-    >>> class GoodEater1(EaterI):
-    ...     def eat(self, food):
-    ...         return 'yum'
-    >>> GoodEater1().eat('steak')
-    'yum'
-    >>> GoodEater1().batch_eat(['steak', 'peas'])
-    ['yum', 'yum']
-
-    >>> class GoodEater2(EaterI):
-    ...     def batch_eat(self, foods):
-    ...         return ['yum' for food in foods]
-    >>> GoodEater2().eat('steak')
-    'yum'
-    >>> GoodEater2().batch_eat(['steak', 'peas'])
-    ['yum', 'yum']
-
-But if a subclass doesn't implement either one, then they'll get an
-error when they try to call them.  (nb this is better than infinite
-recursion):
-
-    >>> class BadEater1(EaterI):
-    ...     pass
-    >>> BadEater1().eat('steak')
-    Traceback (most recent call last):
-      . . .
-    NotImplementedError
-    >>> BadEater1().batch_eat(['steak', 'peas'])
-    Traceback (most recent call last):
-      . . .
-    NotImplementedError
-
-Trying to use the abstract base class itself will also result in an
-error:
-
-    >>> class EaterI(EaterI):
-    ...     pass
-    >>> EaterI().eat('steak')
-    Traceback (most recent call last):
-      . . .
-    NotImplementedError
-    >>> EaterI().batch_eat(['steak', 'peas'])
-    Traceback (most recent call last):
-      . . .
-    NotImplementedError
-
-It's ok to use intermediate abstract classes:
-
-    >>> class AbstractEater(EaterI):
-    ...     pass
-
-    >>> class GoodEater3(AbstractEater):
-    ...     def eat(self, food):
-    ...         return 'yum'
-    ...
-    >>> GoodEater3().eat('steak')
-    'yum'
-    >>> GoodEater3().batch_eat(['steak', 'peas'])
-    ['yum', 'yum']
-
-    >>> class GoodEater4(AbstractEater):
-    ...     def batch_eat(self, foods):
-    ...         return ['yum' for food in foods]
-    >>> GoodEater4().eat('steak')
-    'yum'
-    >>> GoodEater4().batch_eat(['steak', 'peas'])
-    ['yum', 'yum']
-
-    >>> class BadEater2(AbstractEater):
-    ...     pass
-    >>> BadEater2().eat('steak')
-    Traceback (most recent call last):
-      . . .
-    NotImplementedError
-    >>> BadEater2().batch_eat(['steak', 'peas'])
-    Traceback (most recent call last):
-      . . .
-    NotImplementedError
-
-Here's some extra tests:
-
-    >>> class A(object):
-    ...     def f(x): pass
-    >>> class B(A):
-    ...     def f(x): pass
-    >>> class C(A): pass
-    >>> class D(B): pass
-
-    >>> overridden(A().f)
-    False
-    >>> overridden(B().f)
-    True
-    >>> overridden(C().f)
-    False
-    >>> overridden(D().f)
-    True
-
-It works for classic classes, too:
-
-    >>> class A:
-    ...     def f(x): pass
-    >>> class B(A):
-    ...     def f(x): pass
-    >>> class C(A): pass
-    >>> class D(B): pass
-    >>> overridden(A().f)
-    False
-    >>> overridden(B().f)
-    True
-    >>> overridden(C().f)
-    False
-    >>> overridden(D().f)
-    True
+.. Copyright (C) 2001-2018 NLTK Project
+.. For license information, see LICENSE.TXT
+
+==========================================
+ Unit tests for the nltk.utilities module
+==========================================
+
+overridden()
+~~~~~~~~~~~~
+    >>> from nltk.internals import overridden
+
+The typical use case is in defining methods for an interface or
+abstract base class, in such a way that subclasses don't have to
+implement all of the methods:
+
+    >>> class EaterI(object):
+    ...     '''Subclass must define eat() or batch_eat().'''
+    ...     def eat(self, food):
+    ...         if overridden(self.batch_eat):
+    ...             return self.batch_eat([food])[0]
+    ...         else:
+    ...             raise NotImplementedError()
+    ...     def batch_eat(self, foods):
+    ...         return [self.eat(food) for food in foods]
+
+As long as a subclass implements one method, it will be used to
+perform the other method:
+
+    >>> class GoodEater1(EaterI):
+    ...     def eat(self, food):
+    ...         return 'yum'
+    >>> GoodEater1().eat('steak')
+    'yum'
+    >>> GoodEater1().batch_eat(['steak', 'peas'])
+    ['yum', 'yum']
+
+    >>> class GoodEater2(EaterI):
+    ...     def batch_eat(self, foods):
+    ...         return ['yum' for food in foods]
+    >>> GoodEater2().eat('steak')
+    'yum'
+    >>> GoodEater2().batch_eat(['steak', 'peas'])
+    ['yum', 'yum']
+
+But if a subclass doesn't implement either one, then they'll get an
+error when they try to call them.  (nb this is better than infinite
+recursion):
+
+    >>> class BadEater1(EaterI):
+    ...     pass
+    >>> BadEater1().eat('steak')
+    Traceback (most recent call last):
+      . . .
+    NotImplementedError
+    >>> BadEater1().batch_eat(['steak', 'peas'])
+    Traceback (most recent call last):
+      . . .
+    NotImplementedError
+
+Trying to use the abstract base class itself will also result in an
+error:
+
+    >>> class EaterI(EaterI):
+    ...     pass
+    >>> EaterI().eat('steak')
+    Traceback (most recent call last):
+      . . .
+    NotImplementedError
+    >>> EaterI().batch_eat(['steak', 'peas'])
+    Traceback (most recent call last):
+      . . .
+    NotImplementedError
+
+It's ok to use intermediate abstract classes:
+
+    >>> class AbstractEater(EaterI):
+    ...     pass
+
+    >>> class GoodEater3(AbstractEater):
+    ...     def eat(self, food):
+    ...         return 'yum'
+    ...
+    >>> GoodEater3().eat('steak')
+    'yum'
+    >>> GoodEater3().batch_eat(['steak', 'peas'])
+    ['yum', 'yum']
+
+    >>> class GoodEater4(AbstractEater):
+    ...     def batch_eat(self, foods):
+    ...         return ['yum' for food in foods]
+    >>> GoodEater4().eat('steak')
+    'yum'
+    >>> GoodEater4().batch_eat(['steak', 'peas'])
+    ['yum', 'yum']
+
+    >>> class BadEater2(AbstractEater):
+    ...     pass
+    >>> BadEater2().eat('steak')
+    Traceback (most recent call last):
+      . . .
+    NotImplementedError
+    >>> BadEater2().batch_eat(['steak', 'peas'])
+    Traceback (most recent call last):
+      . . .
+    NotImplementedError
+
+Here's some extra tests:
+
+    >>> class A(object):
+    ...     def f(x): pass
+    >>> class B(A):
+    ...     def f(x): pass
+    >>> class C(A): pass
+    >>> class D(B): pass
+
+    >>> overridden(A().f)
+    False
+    >>> overridden(B().f)
+    True
+    >>> overridden(C().f)
+    False
+    >>> overridden(D().f)
+    True
+
+It works for classic classes, too:
+
+    >>> class A:
+    ...     def f(x): pass
+    >>> class B(A):
+    ...     def f(x): pass
+    >>> class C(A): pass
+    >>> class D(B): pass
+    >>> overridden(A().f)
+    False
+    >>> overridden(B().f)
+    True
+    >>> overridden(C().f)
+    False
+    >>> overridden(D().f)
+    True

{nltk-3.2 → nltk-3.3}/nltk/test/japanese.doctest

@@ -1,48 +1,48 @@
-.. Copyright (C) 2001-2015 NLTK Project
-.. For license information, see LICENSE.TXT
-
-============================
-Japanese Language Processing
-============================
-
-    >>> from nltk import *
-
--------------
-Corpus Access
--------------
-
-KNB Corpus
-----------
-
-    >>> from nltk.corpus import knbc
-
-Access the words: this should produce a list of strings:
-
-    >>> type(knbc.words()[0]) is not bytes
-    True
-
-Access the sentences: this should produce a list of lists of strings:
-
-    >>> type(knbc.sents()[0][0]) is not bytes
-    True
-
-Access the tagged words: this should produce a list of word, tag pairs:
-
-    >>> type(knbc.tagged_words()[0])
-    <... 'tuple'>
-
-Access the tagged sentences: this should produce a list of lists of word, tag pairs:
-
-    >>> type(knbc.tagged_sents()[0][0])
-    <... 'tuple'>
-
-
-JEITA Corpus
-------------
-
-    >>> from nltk.corpus import jeita
-
-Access the tagged words: this should produce a list of word, tag pairs, where a tag is a string:
-
-    >>> type(jeita.tagged_words()[0][1]) is not bytes
-    True
+.. Copyright (C) 2001-2018 NLTK Project
+.. For license information, see LICENSE.TXT
+
+============================
+Japanese Language Processing
+============================
+
+    >>> from nltk import *
+
+-------------
+Corpus Access
+-------------
+
+KNB Corpus
+----------
+
+    >>> from nltk.corpus import knbc
+
+Access the words: this should produce a list of strings:
+
+    >>> type(knbc.words()[0]) is not bytes
+    True
+
+Access the sentences: this should produce a list of lists of strings:
+
+    >>> type(knbc.sents()[0][0]) is not bytes
+    True
+
+Access the tagged words: this should produce a list of word, tag pairs:
+
+    >>> type(knbc.tagged_words()[0])
+    <... 'tuple'>
+
+Access the tagged sentences: this should produce a list of lists of word, tag pairs:
+
+    >>> type(knbc.tagged_sents()[0][0])
+    <... 'tuple'>
+
+
+JEITA Corpus
+------------
+
+    >>> from nltk.corpus import jeita
+
+Access the tagged words: this should produce a list of word, tag pairs, where a tag is a string:
+
+    >>> type(jeita.tagged_words()[0][1]) is not bytes
+    True