nltk 3.2.1__zip → 3.3__zip

{nltk-3.2.1 → nltk-3.3}/nltk/test/unit/test_corpora.py

@@ -1,8 +1,11 @@
 # -*- coding: utf-8 -*-
 from __future__ import absolute_import, unicode_literals
 import unittest
+
 from nltk.corpus import (sinica_treebank, conll2007, indian, cess_cat, cess_esp,
-                         floresta, ptb, udhr)
+                         floresta, ptb, udhr) # mwa_ppdb
+
+from nltk.compat import python_2_unicode_compatible
 from nltk.tree import Tree
 from nltk.test.unit.utils import skipIf
 
@@ -179,5 +182,19 @@ class TestPTB(unittest.TestCase):
             ['Thirty-three', 'Scotty', 'did', 'not', 'go', 'back']
         )
 
+@unittest.skip("Skipping test for mwa_ppdb.")
+class TestMWAPPDB(unittest.TestCase):
+    def test_fileids(self):
+        self.assertEqual(mwa_ppdb.fileids(),
+            ['ppdb-1.0-xxxl-lexical.extended.synonyms.uniquepairs'])
+
+    def test_entries(self):
+        self.assertEqual(mwa_ppdb.entries()[:10],
+            [('10/17/01', '17/10/2001'), ('102,70', '102.70'),
+            ('13,53', '13.53'), ('3.2.5.3.2.1', '3.2.5.3.2.1.'),
+            ('53,76', '53.76'), ('6.9.5', '6.9.5.'),
+            ('7.7.6.3', '7.7.6.3.'), ('76,20', '76.20'),
+            ('79,85', '79.85'), ('93,65', '93.65')] )
+
 # unload corpora
 from nltk.corpus import teardown_module

{nltk-3.2.1 → nltk-3.3}/nltk/test/unit/test_json2csv_corpus.py

@@ -1,7 +1,7 @@
 # -*- coding: utf-8 -*-
 # Natural Language Toolkit: Twitter client
 #
-# Copyright (C) 2001-2016 NLTK Project
+# Copyright (C) 2001-2018 NLTK Project
 # Author: Lorenzo Rubio <lrnzcig@gmail.com>
 # URL: <http://nltk.org/>
 # For license information, see LICENSE.TXT
@@ -16,9 +16,10 @@ import os
 from nltk.compat import TemporaryDirectory
 import unittest
 
+from six.moves import zip
+
 from nltk.corpus import twitter_samples
 from nltk.twitter.common import json2csv, json2csv_entities
-from nltk.compat import izip
 
 
 def are_files_identical(filename1, filename2, debug=False):
@@ -28,7 +29,7 @@ def are_files_identical(filename1, filename2, debug=False):
     with open(filename1, "rb") as fileA:
         with open(filename2, "rb") as fileB:
             result = True
-            for lineA, lineB in izip(sorted(fileA.readlines()),
+            for lineA, lineB in zip(sorted(fileA.readlines()),
                                      sorted(fileB.readlines())):
                 if lineA.strip() != lineB.strip():
                     if debug:

nltk-3.3/nltk/test/unit/test_rte_classify.py

@@ -0,0 +1,86 @@
+# -*- coding: utf-8 -*-
+from __future__ import print_function, unicode_literals
+
+import unittest
+
+from nltk.corpus import rte as rte_corpus
+from nltk.classify.rte_classify import RTEFeatureExtractor, rte_features, rte_classifier
+
+expected_from_rte_feature_extration = """
+alwayson        => True
+ne_hyp_extra    => 0
+ne_overlap      => 1
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 3
+word_overlap    => 3
+
+alwayson        => True
+ne_hyp_extra    => 0
+ne_overlap      => 1
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 2
+word_overlap    => 1
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 1
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 1
+word_overlap    => 2
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 0
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 6
+word_overlap    => 2
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 0
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 4
+word_overlap    => 0
+
+alwayson        => True
+ne_hyp_extra    => 1
+ne_overlap      => 0
+neg_hyp         => 0
+neg_txt         => 0
+word_hyp_extra  => 3
+word_overlap    => 1
+"""
+
+
+class RTEClassifierTest(unittest.TestCase):
+    # Test the feature extraction method.
+    def test_rte_feature_extraction(self):
+        pairs = rte_corpus.pairs(['rte1_dev.xml'])[:6]
+        test_output = ["%-15s => %s" % (key, rte_features(pair)[key])
+                       for pair in pairs for key in sorted(rte_features(pair))]
+        expected_output = expected_from_rte_feature_extration.strip().split('\n')
+        # Remove null strings.
+        expected_output = list(filter(None, expected_output))
+        self.assertEqual(test_output, expected_output)
+    # Test the RTEFeatureExtractor object.
+    def test_feature_extractor_object(self):
+        rtepair = rte_corpus.pairs(['rte3_dev.xml'])[33]
+        extractor = RTEFeatureExtractor(rtepair)
+        self.assertEqual(extractor.hyp_words, {'member', 'China', 'SCO.'})
+        self.assertEqual(extractor.overlap('word'), set())
+        self.assertEqual(extractor.overlap('ne'), {'China'})
+        self.assertEqual(extractor.hyp_extra('word'), {'member'})
+    # Test the RTE classifier training.
+    def test_rte_classification_without_megam(self):
+        clf = rte_classifier('IIS')
+        clf = rte_classifier('GIS')
+    @unittest.skip("Skipping tests with dependencies on MEGAM")
+    def test_rte_classification_with_megam(self):
+        nltk.config_megam('/usr/local/bin/megam')
+        clf = rte_classifier('megam')
+        clf = rte_classifier('BFGS')

nltk-3.3/nltk/test/unit/test_senna.py

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

nltk-3.3/nltk/test/unit/test_stem.py

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

{nltk-3.2.1 → nltk-3.3}/nltk/test/unit/test_tgrep.py

@@ -3,7 +3,7 @@
 #
 # Natural Language Toolkit: TGrep search
 #
-# Copyright (C) 2001-2016 NLTK Project
+# Copyright (C) 2001-2018 NLTK Project
 # Author: Will Roberts <wildwilhelm@gmail.com>
 # URL: <http://nltk.org/>
 # For license information, see LICENSE.TXT
@@ -13,7 +13,9 @@ Unit tests for nltk.tgrep.
 '''
 
 from __future__ import absolute_import, print_function, unicode_literals
-from nltk.compat import b
+
+from six import b
+
 from nltk.tree import ParentedTree
 from nltk import tgrep
 import unittest

nltk-3.3/nltk/test/unit/test_tokenize.py

@@ -0,0 +1,168 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for nltk.tokenize.
+See also nltk/test/tokenize.doctest
+"""
+
+from __future__ import unicode_literals
+from nltk.tokenize import TweetTokenizer, StanfordSegmenter, TreebankWordTokenizer
+from nose import SkipTest
+import unittest
+import os
+
+
+class TestTokenize(unittest.TestCase):
+
+    def test_tweet_tokenizer(self):
+        """
+        Test TweetTokenizer using words with special and accented characters.
+        """
+
+        tokenizer = TweetTokenizer(strip_handles=True, reduce_len=True)
+        s9 = "@myke: Let's test these words: resumé España München français"
+        tokens = tokenizer.tokenize(s9)
+        expected = [':', "Let's", 'test', 'these', 'words', ':', 'resumé',
+                    'España', 'München', 'français']
+        self.assertEqual(tokens, expected)
+
+    def test_stanford_segmenter_arabic(self):
+        """
+        Test the Stanford Word Segmenter for Arabic (default config)
+        """
+        try:
+            seg = StanfordSegmenter()
+            seg.default_config('ar')
+            sent = u'يبحث علم الحاسوب استخدام الحوسبة بجميع اشكالها لحل المشكلات'
+            segmented_sent = seg.segment(sent.split())
+            assert segmented_sent.split() == ['يبحث', 'علم', 'الحاسوب', 'استخدام',
+                                              'الحوسبة', 'ب', 'جميع', 'اشكال',
+                                              'ها', 'ل', 'حل', 'المشكلات']
+        except LookupError as e:
+            raise SkipTest(str(e))
+
+    def test_stanford_segmenter_chinese(self):
+        """
+        Test the Stanford Word Segmenter for Chinese (default config)
+        """
+        try:
+            seg = StanfordSegmenter()
+            seg.default_config('zh')
+            sent = u"这是斯坦福中文分词器测试"
+            segmented_sent = seg.segment(sent.split())
+            assert segmented_sent.split() == ['这', '是', '斯坦福',
+                                              '中文', '分词器', '测试']
+        except LookupError as e:
+            raise SkipTest(str(e))
+
+    def test_phone_tokenizer(self):
+        """
+        Test a string that resembles a phone number but contains a newline
+        """
+
+        # Should be recognized as a phone number, albeit one with multiple spaces
+        tokenizer = TweetTokenizer()
+        test1 = "(393)  928 -3010"
+        expected = ['(393)  928 -3010']
+        result = tokenizer.tokenize(test1)
+        self.assertEqual(result, expected)
+
+        # Due to newline, first three elements aren't part of a phone number;
+        # fourth is
+        test2= "(393)\n928 -3010"
+        expected = ['(', '393', ')', "928 -3010"]
+        result = tokenizer.tokenize(test2)
+        self.assertEqual(result, expected)
+
+    def test_remove_handle(self):
+        """
+        Test remove_handle() from casual.py with specially crafted edge cases
+        """
+
+        tokenizer = TweetTokenizer(strip_handles=True)
+
+        # Simple example. Handles with just numbers should be allowed
+        test1 = "@twitter hello @twi_tter_. hi @12345 @123news"
+        expected = ['hello', '.', 'hi']
+        result = tokenizer.tokenize(test1)
+        self.assertEqual(result, expected)
+
+        # Handles are allowed to follow any of the following characters
+        test2 = "@n`@n~@n(@n)@n-@n=@n+@n\\@n|@n[@n]@n{@n}@n;@n:@n'@n\"@n/@n?@n.@n,@n<@n>@n @n\n@n ñ@n.ü@n.ç@n."
+        expected = ['`', '~', '(', ')', '-', '=', '+', '\\', '|', '[', ']', '{', '}', ';', ':', "'", '"', '/', '?', '.', ',', '<', '>', 'ñ', '.', 'ü', '.', 'ç', '.']
+        result = tokenizer.tokenize(test2)
+        self.assertEqual(result, expected)
+
+
+        # Handles are NOT allowed to follow any of the following characters
+        test3 = "a@n j@n z@n A@n L@n Z@n 1@n 4@n 7@n 9@n 0@n _@n !@n @@n #@n $@n %@n &@n *@n"
+        expected = ['a', '@n', 'j', '@n', 'z', '@n', 'A', '@n', 'L', '@n', 'Z', '@n', '1', '@n', '4', '@n', '7', '@n', '9', '@n', '0', '@n', '_', '@n', '!', '@n', '@', '@n', '#', '@n', '$', '@n', '%', '@n', '&', '@n', '*', '@n']
+        result = tokenizer.tokenize(test3)
+        self.assertEqual(result, expected)
+
+
+        # Handles are allowed to precede the following characters
+        test4 = "@n!a @n#a @n$a @n%a @n&a @n*a"
+        expected = ['!', 'a', '#', 'a', '$', 'a', '%', 'a', '&', 'a', '*', 'a']
+        result = tokenizer.tokenize(test4)
+        self.assertEqual(result, expected)
+
+
+        # Tests interactions with special symbols and multiple @
+        test5 = "@n!@n @n#@n @n$@n @n%@n @n&@n @n*@n @n@n @@n @n@@n @n_@n @n7@n @nj@n"
+        expected = ['!', '@n', '#', '@n', '$', '@n', '%', '@n', '&', '@n', '*', '@n', '@n', '@n', '@', '@n', '@n', '@', '@n', '@n_', '@n', '@n7', '@n', '@nj', '@n']
+        result = tokenizer.tokenize(test5)
+        self.assertEqual(result, expected)
+
+
+        # Tests that handles can have a max length of 20
+        test6 = "@abcdefghijklmnopqrstuvwxyz @abcdefghijklmnopqrst1234 @abcdefghijklmnopqrst_ @abcdefghijklmnopqrstendofhandle"
+        expected = ['uvwxyz', '1234', '_', 'endofhandle']
+        result = tokenizer.tokenize(test6)
+        self.assertEqual(result, expected)
+
+
+        # Edge case where an @ comes directly after a long handle
+        test7 = "@abcdefghijklmnopqrstu@abcde @abcdefghijklmnopqrst@abcde @abcdefghijklmnopqrst_@abcde @abcdefghijklmnopqrst5@abcde"
+        expected = ['u', '@abcde', '@abcdefghijklmnopqrst', '@abcde', '_', '@abcde', '5', '@abcde']
+        result = tokenizer.tokenize(test7)
+        self.assertEqual(result, expected)
+
+    def test_treebank_span_tokenizer(self):
+        """
+        Test TreebankWordTokenizer.span_tokenize function
+        """
+
+        tokenizer = TreebankWordTokenizer()
+
+        # Test case in the docstring
+        test1 = "Good muffins cost $3.88\nin New (York).  Please (buy) me\ntwo of them.\n(Thanks)."
+        expected = [
+            (0, 4), (5, 12), (13, 17), (18, 19), (19, 23),
+            (24, 26), (27, 30), (31, 32), (32, 36), (36, 37), (37, 38),
+            (40, 46), (47, 48), (48, 51), (51, 52), (53, 55), (56, 59),
+            (60, 62), (63, 68), (69, 70), (70, 76), (76, 77), (77, 78)
+        ]
+        result = list(tokenizer.span_tokenize(test1))
+        self.assertEqual(result, expected)
+
+        # Test case with double quotation
+        test2 = "The DUP is similar to the \"religious right\" in the United States and takes a hardline stance on social issues"
+        expected = [
+            (0, 3), (4, 7), (8, 10), (11, 18), (19, 21), (22, 25), (26, 27),
+            (27, 36), (37, 42), (42, 43), (44, 46), (47, 50), (51, 57), (58, 64),
+            (65, 68), (69, 74), (75, 76), (77, 85), (86, 92), (93, 95), (96, 102),
+            (103, 109)
+        ]
+        result = list(tokenizer.span_tokenize(test2))
+        self.assertEqual(result, expected)
+
+        # Test case with double qoutation as well as converted quotations
+        test3 = "The DUP is similar to the \"religious right\" in the United States and takes a ``hardline'' stance on social issues"
+        expected = [
+            (0, 3), (4, 7), (8, 10), (11, 18), (19, 21), (22, 25), (26, 27),
+            (27, 36), (37, 42), (42, 43), (44, 46), (47, 50), (51, 57), (58, 64),
+            (65, 68), (69, 74), (75, 76), (77, 79), (79, 87), (87, 89), (90, 96),
+            (97, 99), (100, 106), (107, 113)
+        ]
+        result = list(tokenizer.span_tokenize(test3))
+        self.assertEqual(result, expected)

nltk-3.3/nltk/test/unit/test_wordnet.py

@@ -0,0 +1,134 @@
+# -*- coding: utf-8 -*-
+"""
+Unit tests for nltk.corpus.wordnet
+See also nltk/test/wordnet.doctest
+"""
+
+from __future__ import unicode_literals
+from nose import SkipTest
+import unittest
+import os
+
+from nltk.corpus.reader.wordnet import WordNetCorpusReader
+from nltk.corpus import wordnet as wn
+from nltk.corpus import wordnet_ic as wnic
+from nltk.data import find as find_data
+
+
+wn.ensure_loaded()
+S = wn.synset
+L = wn.lemma
+
+class WordnNetDemo(unittest.TestCase):
+
+    def test_retrieve_synset(self):
+        move_synset = S('go.v.21')
+        self.assertEqual(move_synset.name(), "move.v.15")
+        self.assertEqual(move_synset.lemma_names(), ['move', 'go'])
+        self.assertEqual(move_synset.definition(), "have a turn; make one's move in a game")
+        self.assertEqual(move_synset.examples(), ['Can I go now?'])
+
+
+    def test_retrieve_synsets(self):
+        self.assertEqual(sorted(wn.synsets('zap', pos='n')),
+                        [S('zap.n.01')])
+        self.assertEqual(sorted(wn.synsets('zap', pos='v')),
+                        [S('microwave.v.01'), S('nuke.v.01'), S('zap.v.01'), S('zap.v.02')])
+
+    def test_hyperhyponyms(self):
+        # Not every synset as hypernyms()
+        self.assertEqual(S('travel.v.01').hypernyms(), [])
+        self.assertEqual(S('travel.v.02').hypernyms(),
+                        [S('travel.v.03')])
+        self.assertEqual(S('travel.v.03').hypernyms(), [])
+
+        # Test hyper-/hyponyms.
+        self.assertEqual(S('breakfast.n.1').hypernyms(), [S('meal.n.01')])
+        first_five_meal_hypo = [S('banquet.n.02'), S('bite.n.04'), S('breakfast.n.01'), S('brunch.n.01'), S('buffet.n.02')]
+        self.assertEqual(sorted(S('meal.n.1').hyponyms()[:5]), first_five_meal_hypo)
+        self.assertEqual(S('Austen.n.1').instance_hypernyms(), [S('writer.n.01')])
+        first_five_composer_hypo = [S('ambrose.n.01'), S('bach.n.01'), S('barber.n.01'), S('bartok.n.01'), S('beethoven.n.01')]
+        self.assertEqual(S('composer.n.1').instance_hyponyms()[:5], first_five_composer_hypo)
+
+        # Test root hyper-/hyponyms
+        self.assertEqual(S('person.n.01').root_hypernyms(), [S('entity.n.01')])
+        self.assertEqual(S('sail.v.01').root_hypernyms(), [S('travel.v.01')])
+        self.assertEqual(S('fall.v.12').root_hypernyms(), [S('act.v.01'), S('fall.v.17')])
+
+    def test_derivationally_related_forms(self):
+        # Test `derivationally_related_forms()`
+        self.assertEqual(L('zap.v.03.nuke').derivationally_related_forms(),
+                        [L('atomic_warhead.n.01.nuke')])
+        self.assertEqual(L('zap.v.03.atomize').derivationally_related_forms(),
+                        [L('atomization.n.02.atomization')])
+        self.assertEqual(L('zap.v.03.atomise').derivationally_related_forms(),
+                        [L('atomization.n.02.atomisation')])
+        self.assertEqual(L('zap.v.03.zap').derivationally_related_forms(),
+                        [])
+
+    def test_meronyms_holonyms(self):
+        # Test meronyms, holonyms.
+        self.assertEqual(S('dog.n.01').member_holonyms(), [S('canis.n.01'), S('pack.n.06')])
+        self.assertEqual(S('dog.n.01').part_meronyms(), [S('flag.n.07')])
+
+        self.assertEqual(S('faculty.n.2').member_meronyms(),
+                        [S('professor.n.01')])
+        self.assertEqual(S('copilot.n.1').member_holonyms(),
+                        [S('crew.n.01')])
+
+        self.assertEqual(S('table.n.2').part_meronyms(),
+                        [S('leg.n.03'), S('tabletop.n.01'), S('tableware.n.01')])
+        self.assertEqual(S('course.n.7').part_holonyms(),
+                        [S('meal.n.01')])
+
+        self.assertEqual(S('water.n.1').substance_meronyms(),
+                        [S('hydrogen.n.01'), S('oxygen.n.01')])
+        self.assertEqual(S('gin.n.1').substance_holonyms(),
+                        [S('gin_and_it.n.01'), S('gin_and_tonic.n.01'),
+                         S('martini.n.01'), S('pink_lady.n.01')])
+
+    def test_antonyms(self):
+        # Test antonyms.
+        self.assertEqual(L('leader.n.1.leader').antonyms(), [L('follower.n.01.follower')])
+        self.assertEqual(L('increase.v.1.increase').antonyms(), [L('decrease.v.01.decrease')])
+
+
+    def test_misc_relations(self):
+        # Test misc relations.
+        self.assertEqual(S('snore.v.1').entailments(), [S('sleep.v.01')])
+        self.assertEqual(S('heavy.a.1').similar_tos(),
+                        [S('dense.s.03'), S('doughy.s.01'),
+                         S('heavier-than-air.s.01'), S('hefty.s.02'),
+                         S('massive.s.04'), S('non-buoyant.s.01'),
+                         S('ponderous.s.02')])
+        self.assertEqual(S('light.a.1').attributes(), [S('weight.n.01')])
+        self.assertEqual(S('heavy.a.1').attributes(), [S('weight.n.01')])
+
+        # Test pertainyms.
+        self.assertEqual(L('English.a.1.English').pertainyms(),
+                         [L('england.n.01.England')])
+
+    def test_lch(self):
+        # Test LCH.
+        self.assertEqual(S('person.n.01').lowest_common_hypernyms(S('dog.n.01')),
+                         [S('organism.n.01')])
+        self.assertEqual(S('woman.n.01').lowest_common_hypernyms(S('girlfriend.n.02')),
+                         [S('woman.n.01')])
+
+    def test_domains(self):
+        # Test domains.
+        self.assertEqual(S('code.n.03').topic_domains(), [S('computer_science.n.01')])
+        self.assertEqual(S('pukka.a.01').region_domains(), [S('india.n.01')])
+        self.assertEqual(S('freaky.a.01').usage_domains(), [S('slang.n.02')])
+
+    def test_wordnet_similarities(self):
+        # Path based similarities.
+        self.assertAlmostEqual(S('cat.n.01').path_similarity(S('cat.n.01')), 1.0)
+        self.assertAlmostEqual(S('dog.n.01').path_similarity(S('cat.n.01')), 0.2)
+        self.assertAlmostEqual(S('dog.n.01').lch_similarity(S('cat.n.01')), 2.028, places=3)
+        self.assertAlmostEqual(S('dog.n.01').wup_similarity(S('cat.n.01')), 0.8571, places=3)
+        # Information Content similarities.
+        brown_ic = wnic.ic('ic-brown.dat')
+        self.assertAlmostEqual(S('dog.n.01').jcn_similarity(S('cat.n.01'), brown_ic), 0.4497, places=3)
+        semcor_ic = wnic.ic('ic-semcor.dat')
+        self.assertAlmostEqual(S('dog.n.01').lin_similarity(S('cat.n.01'), semcor_ic), 0.8863, places=3)