Add files using upload-large-folder tool

ckpts/universal/global_step40/zero/23.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:adc9fd2c4ac012d918d5483254176cf5677f7acb9aca04eb0a5de48d3ab81e44
+size 33555612

ckpts/universal/global_step40/zero/6.input_layernorm.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:558d00972395a1abdaeb05804ebc2b14e149d87aafc00ec8771ae9024c7fcb88
+size 9387

ckpts/universal/global_step40/zero/9.mlp.dense_4h_to_h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0bccb633058b03095e3bb5a395f9958a3b40a21d9774b48de31afb6b9159f9b1
+size 33555612

ckpts/universal/global_step40/zero/9.mlp.dense_4h_to_h.weight/exp_avg_sq.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d18144c169fc747fafedab07869308e97394c7193ea3dae1496d21613d800604
+size 33555627

ckpts/universal/global_step40/zero/9.mlp.dense_4h_to_h.weight/fp32.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2caa7a9f2c8a75408fc316af2ebaa594e9f8455d1962917f506ea1ca7d62a29b
+size 33555533

ckpts/universal/global_step40/zero/9.mlp.dense_h_to_4h.weight/exp_avg.pt

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0cd828b3932e0711a39673d9a740d3d3d05ead7dd822e5057f2ec1dfd46211ea
+size 33555612

venv/lib/python3.10/site-packages/nltk/test/parse.doctest

@@ -0,0 +1,933 @@
+.. Copyright (C) 2001-2023 NLTK Project
+.. For license information, see LICENSE.TXT
+
+=========
+ Parsing
+=========
+
+Unit tests for the Context Free Grammar class
+---------------------------------------------
+
+    >>> import pickle
+    >>> import subprocess
+    >>> import sys
+    >>> from nltk import Nonterminal, nonterminals, Production, CFG
+
+    >>> nt1 = Nonterminal('NP')
+    >>> nt2 = Nonterminal('VP')
+
+    >>> nt1.symbol()
+    'NP'
+
+    >>> nt1 == Nonterminal('NP')
+    True
+
+    >>> nt1 == nt2
+    False
+
+    >>> S, NP, VP, PP = nonterminals('S, NP, VP, PP')
+    >>> N, V, P, DT = nonterminals('N, V, P, DT')
+
+    >>> prod1 = Production(S, [NP, VP])
+    >>> prod2 = Production(NP, [DT, NP])
+
+    >>> prod1.lhs()
+    S
+
+    >>> prod1.rhs()
+    (NP, VP)
+
+    >>> prod1 == Production(S, [NP, VP])
+    True
+
+    >>> prod1 == prod2
+    False
+
+    >>> grammar = CFG.fromstring("""
+    ... S -> NP VP
+    ... PP -> P NP
+    ... NP -> 'the' N | N PP | 'the' N PP
+    ... VP -> V NP | V PP | V NP PP
+    ... N -> 'cat'
+    ... N -> 'dog'
+    ... N -> 'rug'
+    ... V -> 'chased'
+    ... V -> 'sat'
+    ... P -> 'in'
+    ... P -> 'on'
+    ... """)
+
+    >>> cmd = """import pickle
+    ... from nltk import Production
+    ... p = Production('S', ['NP', 'VP'])
+    ... print(pickle.dumps(p))
+    ... """
+
+    >>> # Start a subprocess to simulate pickling in another process
+    >>> proc = subprocess.run([sys.executable, '-c', cmd], stdout=subprocess.PIPE)
+    >>> p1 = pickle.loads(eval(proc.stdout))
+    >>> p2 = Production('S', ['NP', 'VP'])
+    >>> print(hash(p1) == hash(p2))
+    True
+
+Unit tests for the rd (Recursive Descent Parser) class
+------------------------------------------------------
+
+Create and run a recursive descent parser over both a syntactically ambiguous
+and unambiguous sentence.
+
+    >>> from nltk.parse import RecursiveDescentParser
+    >>> rd = RecursiveDescentParser(grammar)
+
+    >>> sentence1 = 'the cat chased the dog'.split()
+    >>> sentence2 = 'the cat chased the dog on the rug'.split()
+
+    >>> for t in rd.parse(sentence1):
+    ...     print(t)
+    (S (NP the (N cat)) (VP (V chased) (NP the (N dog))))
+
+    >>> for t in rd.parse(sentence2):
+    ...     print(t)
+    (S
+      (NP the (N cat))
+      (VP (V chased) (NP the (N dog) (PP (P on) (NP the (N rug))))))
+    (S
+      (NP the (N cat))
+      (VP (V chased) (NP the (N dog)) (PP (P on) (NP the (N rug)))))
+
+
+(dolist (expr doctest-font-lock-keywords)
+  (add-to-list 'font-lock-keywords expr))
+
+  font-lock-keywords
+(add-to-list 'font-lock-keywords
+  (car doctest-font-lock-keywords))
+
+
+Unit tests for the sr (Shift Reduce Parser) class
+-------------------------------------------------
+
+Create and run a shift reduce parser over both a syntactically ambiguous
+and unambiguous sentence. Note that unlike the recursive descent parser, one
+and only one parse is ever returned.
+
+    >>> from nltk.parse import ShiftReduceParser
+    >>> sr = ShiftReduceParser(grammar)
+
+    >>> sentence1 = 'the cat chased the dog'.split()
+    >>> sentence2 = 'the cat chased the dog on the rug'.split()
+
+    >>> for t in sr.parse(sentence1):
+    ...     print(t)
+    (S (NP the (N cat)) (VP (V chased) (NP the (N dog))))
+
+
+The shift reduce parser uses heuristics to decide what to do when there are
+multiple possible shift or reduce operations available - for the supplied
+grammar clearly the wrong operation is selected.
+
+    >>> for t in sr.parse(sentence2):
+    ...     print(t)
+
+
+Unit tests for the Chart Parser class
+-------------------------------------
+
+We use the demo() function for testing.
+We must turn off showing of times.
+
+    >>> import nltk
+
+First we test tracing with a short sentence
+
+    >>> nltk.parse.chart.demo(2, print_times=False, trace=1,
+    ...                       sent='I saw a dog', numparses=1)
+    * Sentence:
+    I saw a dog
+    ['I', 'saw', 'a', 'dog']
+    <BLANKLINE>
+    * Strategy: Bottom-up
+    <BLANKLINE>
+    |.    I    .   saw   .    a    .   dog   .|
+    |[---------]         .         .         .| [0:1] 'I'
+    |.         [---------]         .         .| [1:2] 'saw'
+    |.         .         [---------]         .| [2:3] 'a'
+    |.         .         .         [---------]| [3:4] 'dog'
+    |>         .         .         .         .| [0:0] NP -> * 'I'
+    |[---------]         .         .         .| [0:1] NP -> 'I' *
+    |>         .         .         .         .| [0:0] S  -> * NP VP
+    |>         .         .         .         .| [0:0] NP -> * NP PP
+    |[--------->         .         .         .| [0:1] S  -> NP * VP
+    |[--------->         .         .         .| [0:1] NP -> NP * PP
+    |.         >         .         .         .| [1:1] Verb -> * 'saw'
+    |.         [---------]         .         .| [1:2] Verb -> 'saw' *
+    |.         >         .         .         .| [1:1] VP -> * Verb NP
+    |.         >         .         .         .| [1:1] VP -> * Verb
+    |.         [--------->         .         .| [1:2] VP -> Verb * NP
+    |.         [---------]         .         .| [1:2] VP -> Verb *
+    |.         >         .         .         .| [1:1] VP -> * VP PP
+    |[-------------------]         .         .| [0:2] S  -> NP VP *
+    |.         [--------->         .         .| [1:2] VP -> VP * PP
+    |.         .         >         .         .| [2:2] Det -> * 'a'
+    |.         .         [---------]         .| [2:3] Det -> 'a' *
+    |.         .         >         .         .| [2:2] NP -> * Det Noun
+    |.         .         [--------->         .| [2:3] NP -> Det * Noun
+    |.         .         .         >         .| [3:3] Noun -> * 'dog'
+    |.         .         .         [---------]| [3:4] Noun -> 'dog' *
+    |.         .         [-------------------]| [2:4] NP -> Det Noun *
+    |.         .         >         .         .| [2:2] S  -> * NP VP
+    |.         .         >         .         .| [2:2] NP -> * NP PP
+    |.         [-----------------------------]| [1:4] VP -> Verb NP *
+    |.         .         [------------------->| [2:4] S  -> NP * VP
+    |.         .         [------------------->| [2:4] NP -> NP * PP
+    |[=======================================]| [0:4] S  -> NP VP *
+    |.         [----------------------------->| [1:4] VP -> VP * PP
+    Nr edges in chart: 33
+    (S (NP I) (VP (Verb saw) (NP (Det a) (Noun dog))))
+    <BLANKLINE>
+
+Then we test the different parsing Strategies.
+Note that the number of edges differ between the strategies.
+
+Top-down
+
+    >>> nltk.parse.chart.demo(1, print_times=False, trace=0,
+    ...                       sent='I saw John with a dog', numparses=2)
+    * Sentence:
+    I saw John with a dog
+    ['I', 'saw', 'John', 'with', 'a', 'dog']
+    <BLANKLINE>
+    * Strategy: Top-down
+    <BLANKLINE>
+    Nr edges in chart: 48
+    (S
+      (NP I)
+      (VP (Verb saw) (NP (NP John) (PP with (NP (Det a) (Noun dog))))))
+    (S
+      (NP I)
+      (VP (VP (Verb saw) (NP John)) (PP with (NP (Det a) (Noun dog)))))
+    <BLANKLINE>
+
+Bottom-up
+
+    >>> nltk.parse.chart.demo(2, print_times=False, trace=0,
+    ...                       sent='I saw John with a dog', numparses=2)
+    * Sentence:
+    I saw John with a dog
+    ['I', 'saw', 'John', 'with', 'a', 'dog']
+    <BLANKLINE>
+    * Strategy: Bottom-up
+    <BLANKLINE>
+    Nr edges in chart: 53
+    (S
+      (NP I)
+      (VP (VP (Verb saw) (NP John)) (PP with (NP (Det a) (Noun dog)))))
+    (S
+      (NP I)
+      (VP (Verb saw) (NP (NP John) (PP with (NP (Det a) (Noun dog))))))
+    <BLANKLINE>
+
+Bottom-up Left-Corner
+
+    >>> nltk.parse.chart.demo(3, print_times=False, trace=0,
+    ...                       sent='I saw John with a dog', numparses=2)
+    * Sentence:
+    I saw John with a dog
+    ['I', 'saw', 'John', 'with', 'a', 'dog']
+    <BLANKLINE>
+    * Strategy: Bottom-up left-corner
+    <BLANKLINE>
+    Nr edges in chart: 36
+    (S
+      (NP I)
+      (VP (VP (Verb saw) (NP John)) (PP with (NP (Det a) (Noun dog)))))
+    (S
+      (NP I)
+      (VP (Verb saw) (NP (NP John) (PP with (NP (Det a) (Noun dog))))))
+    <BLANKLINE>
+
+Left-Corner with Bottom-Up Filter
+
+    >>> nltk.parse.chart.demo(4, print_times=False, trace=0,
+    ...                       sent='I saw John with a dog', numparses=2)
+    * Sentence:
+    I saw John with a dog
+    ['I', 'saw', 'John', 'with', 'a', 'dog']
+    <BLANKLINE>
+    * Strategy: Filtered left-corner
+    <BLANKLINE>
+    Nr edges in chart: 28
+    (S
+      (NP I)
+      (VP (VP (Verb saw) (NP John)) (PP with (NP (Det a) (Noun dog)))))
+    (S
+      (NP I)
+      (VP (Verb saw) (NP (NP John) (PP with (NP (Det a) (Noun dog))))))
+    <BLANKLINE>
+
+The stepping chart parser
+
+    >>> nltk.parse.chart.demo(5, print_times=False, trace=1,
+    ...                       sent='I saw John with a dog', numparses=2)
+    * Sentence:
+    I saw John with a dog
+    ['I', 'saw', 'John', 'with', 'a', 'dog']
+    <BLANKLINE>
+    * Strategy: Stepping (top-down vs bottom-up)
+    <BLANKLINE>
+    *** SWITCH TO TOP DOWN
+    |[------]      .      .      .      .      .| [0:1] 'I'
+    |.      [------]      .      .      .      .| [1:2] 'saw'
+    |.      .      [------]      .      .      .| [2:3] 'John'
+    |.      .      .      [------]      .      .| [3:4] 'with'
+    |.      .      .      .      [------]      .| [4:5] 'a'
+    |.      .      .      .      .      [------]| [5:6] 'dog'
+    |>      .      .      .      .      .      .| [0:0] S  -> * NP VP
+    |>      .      .      .      .      .      .| [0:0] NP -> * NP PP
+    |>      .      .      .      .      .      .| [0:0] NP -> * Det Noun
+    |>      .      .      .      .      .      .| [0:0] NP -> * 'I'
+    |[------]      .      .      .      .      .| [0:1] NP -> 'I' *
+    |[------>      .      .      .      .      .| [0:1] S  -> NP * VP
+    |[------>      .      .      .      .      .| [0:1] NP -> NP * PP
+    |.      >      .      .      .      .      .| [1:1] VP -> * VP PP
+    |.      >      .      .      .      .      .| [1:1] VP -> * Verb NP
+    |.      >      .      .      .      .      .| [1:1] VP -> * Verb
+    |.      >      .      .      .      .      .| [1:1] Verb -> * 'saw'
+    |.      [------]      .      .      .      .| [1:2] Verb -> 'saw' *
+    |.      [------>      .      .      .      .| [1:2] VP -> Verb * NP
+    |.      [------]      .      .      .      .| [1:2] VP -> Verb *
+    |[-------------]      .      .      .      .| [0:2] S  -> NP VP *
+    |.      [------>      .      .      .      .| [1:2] VP -> VP * PP
+    *** SWITCH TO BOTTOM UP
+    |.      .      >      .      .      .      .| [2:2] NP -> * 'John'
+    |.      .      .      >      .      .      .| [3:3] PP -> * 'with' NP
+    |.      .      .      >      .      .      .| [3:3] Prep -> * 'with'
+    |.      .      .      .      >      .      .| [4:4] Det -> * 'a'
+    |.      .      .      .      .      >      .| [5:5] Noun -> * 'dog'
+    |.      .      [------]      .      .      .| [2:3] NP -> 'John' *
+    |.      .      .      [------>      .      .| [3:4] PP -> 'with' * NP
+    |.      .      .      [------]      .      .| [3:4] Prep -> 'with' *
+    |.      .      .      .      [------]      .| [4:5] Det -> 'a' *
+    |.      .      .      .      .      [------]| [5:6] Noun -> 'dog' *
+    |.      [-------------]      .      .      .| [1:3] VP -> Verb NP *
+    |[--------------------]      .      .      .| [0:3] S  -> NP VP *
+    |.      [------------->      .      .      .| [1:3] VP -> VP * PP
+    |.      .      >      .      .      .      .| [2:2] S  -> * NP VP
+    |.      .      >      .      .      .      .| [2:2] NP -> * NP PP
+    |.      .      .      .      >      .      .| [4:4] NP -> * Det Noun
+    |.      .      [------>      .      .      .| [2:3] S  -> NP * VP
+    |.      .      [------>      .      .      .| [2:3] NP -> NP * PP
+    |.      .      .      .      [------>      .| [4:5] NP -> Det * Noun
+    |.      .      .      .      [-------------]| [4:6] NP -> Det Noun *
+    |.      .      .      [--------------------]| [3:6] PP -> 'with' NP *
+    |.      [----------------------------------]| [1:6] VP -> VP PP *
+    *** SWITCH TO TOP DOWN
+    |.      .      >      .      .      .      .| [2:2] NP -> * Det Noun
+    |.      .      .      .      >      .      .| [4:4] NP -> * NP PP
+    |.      .      .      >      .      .      .| [3:3] VP -> * VP PP
+    |.      .      .      >      .      .      .| [3:3] VP -> * Verb NP
+    |.      .      .      >      .      .      .| [3:3] VP -> * Verb
+    |[=========================================]| [0:6] S  -> NP VP *
+    |.      [---------------------------------->| [1:6] VP -> VP * PP
+    |.      .      [---------------------------]| [2:6] NP -> NP PP *
+    |.      .      .      .      [------------->| [4:6] NP -> NP * PP
+    |.      [----------------------------------]| [1:6] VP -> Verb NP *
+    |.      .      [--------------------------->| [2:6] S  -> NP * VP
+    |.      .      [--------------------------->| [2:6] NP -> NP * PP
+    |[=========================================]| [0:6] S  -> NP VP *
+    |.      [---------------------------------->| [1:6] VP -> VP * PP
+    |.      .      .      .      .      .      >| [6:6] VP -> * VP PP
+    |.      .      .      .      .      .      >| [6:6] VP -> * Verb NP
+    |.      .      .      .      .      .      >| [6:6] VP -> * Verb
+    *** SWITCH TO BOTTOM UP
+    |.      .      .      .      >      .      .| [4:4] S  -> * NP VP
+    |.      .      .      .      [------------->| [4:6] S  -> NP * VP
+    *** SWITCH TO TOP DOWN
+    *** SWITCH TO BOTTOM UP
+    *** SWITCH TO TOP DOWN
+    *** SWITCH TO BOTTOM UP
+    *** SWITCH TO TOP DOWN
+    *** SWITCH TO BOTTOM UP
+    Nr edges in chart: 61
+    (S
+      (NP I)
+      (VP (VP (Verb saw) (NP John)) (PP with (NP (Det a) (Noun dog)))))
+    (S
+      (NP I)
+      (VP (Verb saw) (NP (NP John) (PP with (NP (Det a) (Noun dog))))))
+    <BLANKLINE>
+
+
+Unit tests for the Incremental Chart Parser class
+-------------------------------------------------
+
+The incremental chart parsers are defined in earleychart.py.
+We use the demo() function for testing. We must turn off showing of times.
+
+    >>> import nltk
+
+Earley Chart Parser
+
+    >>> nltk.parse.earleychart.demo(print_times=False, trace=1,
+    ...                             sent='I saw John with a dog', numparses=2)
+    * Sentence:
+    I saw John with a dog
+    ['I', 'saw', 'John', 'with', 'a', 'dog']
+    <BLANKLINE>
+    |.  I   . saw  . John . with .  a   . dog  .|
+    |[------]      .      .      .      .      .| [0:1] 'I'
+    |.      [------]      .      .      .      .| [1:2] 'saw'
+    |.      .      [------]      .      .      .| [2:3] 'John'
+    |.      .      .      [------]      .      .| [3:4] 'with'
+    |.      .      .      .      [------]      .| [4:5] 'a'
+    |.      .      .      .      .      [------]| [5:6] 'dog'
+    |>      .      .      .      .      .      .| [0:0] S  -> * NP VP
+    |>      .      .      .      .      .      .| [0:0] NP -> * NP PP
+    |>      .      .      .      .      .      .| [0:0] NP -> * Det Noun
+    |>      .      .      .      .      .      .| [0:0] NP -> * 'I'
+    |[------]      .      .      .      .      .| [0:1] NP -> 'I' *
+    |[------>      .      .      .      .      .| [0:1] S  -> NP * VP
+    |[------>      .      .      .      .      .| [0:1] NP -> NP * PP
+    |.      >      .      .      .      .      .| [1:1] VP -> * VP PP
+    |.      >      .      .      .      .      .| [1:1] VP -> * Verb NP
+    |.      >      .      .      .      .      .| [1:1] VP -> * Verb
+    |.      >      .      .      .      .      .| [1:1] Verb -> * 'saw'
+    |.      [------]      .      .      .      .| [1:2] Verb -> 'saw' *
+    |.      [------>      .      .      .      .| [1:2] VP -> Verb * NP
+    |.      [------]      .      .      .      .| [1:2] VP -> Verb *
+    |[-------------]      .      .      .      .| [0:2] S  -> NP VP *
+    |.      [------>      .      .      .      .| [1:2] VP -> VP * PP
+    |.      .      >      .      .      .      .| [2:2] NP -> * NP PP
+    |.      .      >      .      .      .      .| [2:2] NP -> * Det Noun
+    |.      .      >      .      .      .      .| [2:2] NP -> * 'John'
+    |.      .      [------]      .      .      .| [2:3] NP -> 'John' *
+    |.      [-------------]      .      .      .| [1:3] VP -> Verb NP *
+    |.      .      [------>      .      .      .| [2:3] NP -> NP * PP
+    |.      .      .      >      .      .      .| [3:3] PP -> * 'with' NP
+    |[--------------------]      .      .      .| [0:3] S  -> NP VP *
+    |.      [------------->      .      .      .| [1:3] VP -> VP * PP
+    |.      .      .      [------>      .      .| [3:4] PP -> 'with' * NP
+    |.      .      .      .      >      .      .| [4:4] NP -> * NP PP
+    |.      .      .      .      >      .      .| [4:4] NP -> * Det Noun
+    |.      .      .      .      >      .      .| [4:4] Det -> * 'a'
+    |.      .      .      .      [------]      .| [4:5] Det -> 'a' *
+    |.      .      .      .      [------>      .| [4:5] NP -> Det * Noun
+    |.      .      .      .      .      >      .| [5:5] Noun -> * 'dog'
+    |.      .      .      .      .      [------]| [5:6] Noun -> 'dog' *
+    |.      .      .      .      [-------------]| [4:6] NP -> Det Noun *
+    |.      .      .      [--------------------]| [3:6] PP -> 'with' NP *
+    |.      .      .      .      [------------->| [4:6] NP -> NP * PP
+    |.      .      [---------------------------]| [2:6] NP -> NP PP *
+    |.      [----------------------------------]| [1:6] VP -> VP PP *
+    |[=========================================]| [0:6] S  -> NP VP *
+    |.      [---------------------------------->| [1:6] VP -> VP * PP
+    |.      [----------------------------------]| [1:6] VP -> Verb NP *
+    |.      .      [--------------------------->| [2:6] NP -> NP * PP
+    |[=========================================]| [0:6] S  -> NP VP *
+    |.      [---------------------------------->| [1:6] VP -> VP * PP
+    (S
+      (NP I)
+      (VP (VP (Verb saw) (NP John)) (PP with (NP (Det a) (Noun dog)))))
+    (S
+      (NP I)
+      (VP (Verb saw) (NP (NP John) (PP with (NP (Det a) (Noun dog))))))
+
+
+Unit tests for LARGE context-free grammars
+------------------------------------------
+
+Reading the ATIS grammar.
+
+    >>> grammar = nltk.data.load('grammars/large_grammars/atis.cfg')
+    >>> grammar
+    <Grammar with 5517 productions>
+
+Reading the test sentences.
+
+    >>> sentences = nltk.data.load('grammars/large_grammars/atis_sentences.txt')
+    >>> sentences = nltk.parse.util.extract_test_sentences(sentences)
+    >>> len(sentences)
+    98
+    >>> testsentence = sentences[22]
+    >>> testsentence[0]
+    ['show', 'me', 'northwest', 'flights', 'to', 'detroit', '.']
+    >>> testsentence[1]
+    17
+    >>> sentence = testsentence[0]
+
+Now we test all different parsing strategies.
+Note that the number of edges differ between the strategies.
+
+Bottom-up parsing.
+
+    >>> parser = nltk.parse.BottomUpChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    7661
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Bottom-up Left-corner parsing.
+
+    >>> parser = nltk.parse.BottomUpLeftCornerChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    4986
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Left-corner parsing with bottom-up filter.
+
+    >>> parser = nltk.parse.LeftCornerChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    1342
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Top-down parsing.
+
+    >>> parser = nltk.parse.TopDownChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    28352
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Incremental Bottom-up parsing.
+
+    >>> parser = nltk.parse.IncrementalBottomUpChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    7661
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Incremental Bottom-up Left-corner parsing.
+
+    >>> parser = nltk.parse.IncrementalBottomUpLeftCornerChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    4986
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Incremental Left-corner parsing with bottom-up filter.
+
+    >>> parser = nltk.parse.IncrementalLeftCornerChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    1342
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Incremental Top-down parsing.
+
+    >>> parser = nltk.parse.IncrementalTopDownChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    28352
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+Earley parsing. This is similar to the incremental top-down algorithm.
+
+    >>> parser = nltk.parse.EarleyChartParser(grammar)
+    >>> chart = parser.chart_parse(sentence)
+    >>> print((chart.num_edges()))
+    28352
+    >>> print((len(list(chart.parses(grammar.start())))))
+    17
+
+
+Unit tests for the Probabilistic CFG class
+------------------------------------------
+
+    >>> from nltk.corpus import treebank
+    >>> from itertools import islice
+    >>> from nltk.grammar import PCFG, induce_pcfg
+    >>> toy_pcfg1 = PCFG.fromstring("""
+    ...     S -> NP VP [1.0]
+    ...     NP -> Det N [0.5] | NP PP [0.25] | 'John' [0.1] | 'I' [0.15]
+    ...     Det -> 'the' [0.8] | 'my' [0.2]
+    ...     N -> 'man' [0.5] | 'telescope' [0.5]
+    ...     VP -> VP PP [0.1] | V NP [0.7] | V [0.2]
+    ...     V -> 'ate' [0.35] | 'saw' [0.65]
+    ...     PP -> P NP [1.0]
+    ...     P -> 'with' [0.61] | 'under' [0.39]
+    ...     """)
+
+    >>> toy_pcfg2 = PCFG.fromstring("""
+    ...     S    -> NP VP         [1.0]
+    ...     VP   -> V NP          [.59]
+    ...     VP   -> V             [.40]
+    ...     VP   -> VP PP         [.01]
+    ...     NP   -> Det N         [.41]
+    ...     NP   -> Name          [.28]
+    ...     NP   -> NP PP         [.31]
+    ...     PP   -> P NP          [1.0]
+    ...     V    -> 'saw'         [.21]
+    ...     V    -> 'ate'         [.51]
+    ...     V    -> 'ran'         [.28]
+    ...     N    -> 'boy'         [.11]
+    ...     N    -> 'cookie'      [.12]
+    ...     N    -> 'table'       [.13]
+    ...     N    -> 'telescope'   [.14]
+    ...     N    -> 'hill'        [.5]
+    ...     Name -> 'Jack'        [.52]
+    ...     Name -> 'Bob'         [.48]
+    ...     P    -> 'with'        [.61]
+    ...     P    -> 'under'       [.39]
+    ...     Det  -> 'the'         [.41]
+    ...     Det  -> 'a'           [.31]
+    ...     Det  -> 'my'          [.28]
+    ...     """)
+
+Create a set of PCFG productions.
+
+    >>> grammar = PCFG.fromstring("""
+    ... A -> B B [.3] | C B C [.7]
+    ... B -> B D [.5] | C [.5]
+    ... C -> 'a' [.1] | 'b' [0.9]
+    ... D -> 'b' [1.0]
+    ... """)
+    >>> prod = grammar.productions()[0]
+    >>> prod
+    A -> B B [0.3]
+
+    >>> prod.lhs()
+    A
+
+    >>> prod.rhs()
+    (B, B)
+
+    >>> print((prod.prob()))
+    0.3
+
+    >>> grammar.start()
+    A
+
+    >>> grammar.productions()
+    [A -> B B [0.3], A -> C B C [0.7], B -> B D [0.5], B -> C [0.5], C -> 'a' [0.1], C -> 'b' [0.9], D -> 'b' [1.0]]
+
+Induce some productions using parsed Treebank data.
+
+    >>> productions = []
+    >>> for fileid in treebank.fileids()[:2]:
+    ...     for t in treebank.parsed_sents(fileid):
+    ...         productions += t.productions()
+
+    >>> grammar = induce_pcfg(S, productions)
+    >>> grammar
+    <Grammar with 71 productions>
+
+    >>> sorted(grammar.productions(lhs=Nonterminal('PP')))[:2]
+    [PP -> IN NP [1.0]]
+    >>> sorted(grammar.productions(lhs=Nonterminal('NNP')))[:2]
+    [NNP -> 'Agnew' [0.0714286], NNP -> 'Consolidated' [0.0714286]]
+    >>> sorted(grammar.productions(lhs=Nonterminal('JJ')))[:2]
+    [JJ -> 'British' [0.142857], JJ -> 'former' [0.142857]]
+    >>> sorted(grammar.productions(lhs=Nonterminal('NP')))[:2]
+    [NP -> CD NNS [0.133333], NP -> DT JJ JJ NN [0.0666667]]
+
+Unit tests for the Probabilistic Chart Parse classes
+----------------------------------------------------
+
+    >>> tokens = "Jack saw Bob with my cookie".split()
+    >>> grammar = toy_pcfg2
+    >>> print(grammar)
+    Grammar with 23 productions (start state = S)
+        S -> NP VP [1.0]
+        VP -> V NP [0.59]
+        VP -> V [0.4]
+        VP -> VP PP [0.01]
+        NP -> Det N [0.41]
+        NP -> Name [0.28]
+        NP -> NP PP [0.31]
+        PP -> P NP [1.0]
+        V -> 'saw' [0.21]
+        V -> 'ate' [0.51]
+        V -> 'ran' [0.28]
+        N -> 'boy' [0.11]
+        N -> 'cookie' [0.12]
+        N -> 'table' [0.13]
+        N -> 'telescope' [0.14]
+        N -> 'hill' [0.5]
+        Name -> 'Jack' [0.52]
+        Name -> 'Bob' [0.48]
+        P -> 'with' [0.61]
+        P -> 'under' [0.39]
+        Det -> 'the' [0.41]
+        Det -> 'a' [0.31]
+        Det -> 'my' [0.28]
+
+Create several parsers using different queuing strategies and show the
+resulting parses.
+
+    >>> from nltk.parse import pchart
+
+    >>> parser = pchart.InsideChartParser(grammar)
+    >>> for t in parser.parse(tokens):
+    ...     print(t)
+    (S
+      (NP (Name Jack))
+      (VP
+        (V saw)
+        (NP
+          (NP (Name Bob))
+          (PP (P with) (NP (Det my) (N cookie)))))) (p=6.31607e-06)
+    (S
+      (NP (Name Jack))
+      (VP
+        (VP (V saw) (NP (Name Bob)))
+        (PP (P with) (NP (Det my) (N cookie))))) (p=2.03744e-07)
+
+    >>> parser = pchart.RandomChartParser(grammar)
+    >>> for t in parser.parse(tokens):
+    ...     print(t)
+    (S
+      (NP (Name Jack))
+      (VP
+        (V saw)
+        (NP
+          (NP (Name Bob))
+          (PP (P with) (NP (Det my) (N cookie)))))) (p=6.31607e-06)
+    (S
+      (NP (Name Jack))
+      (VP
+        (VP (V saw) (NP (Name Bob)))
+        (PP (P with) (NP (Det my) (N cookie))))) (p=2.03744e-07)
+
+    >>> parser = pchart.UnsortedChartParser(grammar)
+    >>> for t in parser.parse(tokens):
+    ...     print(t)
+    (S
+      (NP (Name Jack))
+      (VP
+        (V saw)
+        (NP
+          (NP (Name Bob))
+          (PP (P with) (NP (Det my) (N cookie)))))) (p=6.31607e-06)
+    (S
+      (NP (Name Jack))
+      (VP
+        (VP (V saw) (NP (Name Bob)))
+        (PP (P with) (NP (Det my) (N cookie))))) (p=2.03744e-07)
+
+    >>> parser = pchart.LongestChartParser(grammar)
+    >>> for t in parser.parse(tokens):
+    ...     print(t)
+    (S
+      (NP (Name Jack))
+      (VP
+        (V saw)
+        (NP
+          (NP (Name Bob))
+          (PP (P with) (NP (Det my) (N cookie)))))) (p=6.31607e-06)
+    (S
+      (NP (Name Jack))
+      (VP
+        (VP (V saw) (NP (Name Bob)))
+        (PP (P with) (NP (Det my) (N cookie))))) (p=2.03744e-07)
+
+    >>> parser = pchart.InsideChartParser(grammar, beam_size = len(tokens)+1)
+    >>> for t in parser.parse(tokens):
+    ...     print(t)
+
+
+Unit tests for the Viterbi Parse classes
+----------------------------------------
+
+    >>> from nltk.parse import ViterbiParser
+    >>> tokens = "Jack saw Bob with my cookie".split()
+    >>> grammar = toy_pcfg2
+
+Parse the tokenized sentence.
+
+    >>> parser = ViterbiParser(grammar)
+    >>> for t in parser.parse(tokens):
+    ...     print(t)
+    (S
+      (NP (Name Jack))
+      (VP
+        (V saw)
+        (NP
+          (NP (Name Bob))
+          (PP (P with) (NP (Det my) (N cookie)))))) (p=6.31607e-06)
+
+
+Unit tests for the FeatStructNonterminal class
+----------------------------------------------
+
+    >>> from nltk.grammar import FeatStructNonterminal
+    >>> FeatStructNonterminal(
+    ...     pos='n', agr=FeatStructNonterminal(number='pl', gender='f'))
+    [agr=[gender='f', number='pl'], pos='n']
+
+    >>> FeatStructNonterminal('VP[+fin]/NP[+pl]')
+    VP[+fin]/NP[+pl]
+
+
+Tracing the Feature Chart Parser
+--------------------------------
+
+We use the featurechart.demo() function for tracing the Feature Chart Parser.
+
+    >>> nltk.parse.featurechart.demo(print_times=False,
+    ...                              print_grammar=True,
+    ...                              parser=nltk.parse.featurechart.FeatureChartParser,
+    ...                              sent='I saw John with a dog')
+    <BLANKLINE>
+    Grammar with 18 productions (start state = S[])
+        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'
+    <BLANKLINE>
+    * FeatureChartParser
+    Sentence: I saw John with a dog
+    |.I.s.J.w.a.d.|
+    |[-] . . . . .| [0:1] 'I'
+    |. [-] . . . .| [1:2] 'saw'
+    |. . [-] . . .| [2:3] 'John'
+    |. . . [-] . .| [3:4] 'with'
+    |. . . . [-] .| [4:5] 'a'
+    |. . . . . [-]| [5:6] 'dog'
+    |[-] . . . . .| [0:1] NP[] -> 'I' *
+    |[-> . . . . .| [0:1] S[] -> NP[] * VP[] {}
+    |[-> . . . . .| [0:1] NP[] -> NP[] * PP[] {}
+    |. [-] . . . .| [1:2] Verb[] -> 'saw' *
+    |. [-> . . . .| [1:2] VP[] -> Verb[] * NP[] {}
+    |. [-] . . . .| [1:2] VP[] -> Verb[] *
+    |. [-> . . . .| [1:2] VP[] -> VP[] * PP[] {}
+    |[---] . . . .| [0:2] S[] -> NP[] VP[] *
+    |. . [-] . . .| [2:3] NP[] -> 'John' *
+    |. . [-> . . .| [2:3] S[] -> NP[] * VP[] {}
+    |. . [-> . . .| [2:3] NP[] -> NP[] * PP[] {}
+    |. [---] . . .| [1:3] VP[] -> Verb[] NP[] *
+    |. [---> . . .| [1:3] VP[] -> VP[] * PP[] {}
+    |[-----] . . .| [0:3] S[] -> NP[] VP[] *
+    |. . . [-] . .| [3:4] Prep[] -> 'with' *
+    |. . . [-> . .| [3:4] PP[] -> Prep[] * NP[] {}
+    |. . . . [-] .| [4:5] Det[-pl] -> 'a' *
+    |. . . . [-> .| [4:5] NP[] -> Det[pl=?x] * Noun[pl=?x] {?x: False}
+    |. . . . . [-]| [5:6] Noun[-pl] -> 'dog' *
+    |. . . . [---]| [4:6] NP[] -> Det[-pl] Noun[-pl] *
+    |. . . . [--->| [4:6] S[] -> NP[] * VP[] {}
+    |. . . . [--->| [4:6] NP[] -> NP[] * PP[] {}
+    |. . . [-----]| [3:6] PP[] -> Prep[] NP[] *
+    |. . [-------]| [2:6] NP[] -> NP[] PP[] *
+    |. [---------]| [1:6] VP[] -> VP[] PP[] *
+    |. [--------->| [1:6] VP[] -> VP[] * PP[] {}
+    |[===========]| [0:6] S[] -> NP[] VP[] *
+    |. . [------->| [2:6] S[] -> NP[] * VP[] {}
+    |. . [------->| [2:6] NP[] -> NP[] * PP[] {}
+    |. [---------]| [1:6] VP[] -> Verb[] NP[] *
+    |. [--------->| [1:6] VP[] -> VP[] * PP[] {}
+    |[===========]| [0:6] S[] -> NP[] VP[] *
+    (S[]
+      (NP[] I)
+      (VP[]
+        (VP[] (Verb[] saw) (NP[] John))
+        (PP[] (Prep[] with) (NP[] (Det[-pl] a) (Noun[-pl] dog)))))
+    (S[]
+      (NP[] I)
+      (VP[]
+        (Verb[] saw)
+        (NP[]
+          (NP[] John)
+          (PP[] (Prep[] with) (NP[] (Det[-pl] a) (Noun[-pl] dog))))))
+
+
+Unit tests for the Feature Chart Parser classes
+-----------------------------------------------
+
+The list of parsers we want to test.
+
+    >>> parsers = [nltk.parse.featurechart.FeatureChartParser,
+    ...            nltk.parse.featurechart.FeatureTopDownChartParser,
+    ...            nltk.parse.featurechart.FeatureBottomUpChartParser,
+    ...            nltk.parse.featurechart.FeatureBottomUpLeftCornerChartParser,
+    ...            nltk.parse.earleychart.FeatureIncrementalChartParser,
+    ...            nltk.parse.earleychart.FeatureEarleyChartParser,
+    ...            nltk.parse.earleychart.FeatureIncrementalTopDownChartParser,
+    ...            nltk.parse.earleychart.FeatureIncrementalBottomUpChartParser,
+    ...            nltk.parse.earleychart.FeatureIncrementalBottomUpLeftCornerChartParser,
+    ...            ]
+
+A helper function that tests each parser on the given grammar and sentence.
+We check that the number of trees are correct, and that all parsers
+return the same trees. Otherwise an error is printed.
+
+    >>> def unittest(grammar, sentence, nr_trees):
+    ...     sentence = sentence.split()
+    ...     trees = None
+    ...     for P in parsers:
+    ...         result = P(grammar).parse(sentence)
+    ...         result = set(tree.freeze() for tree in result)
+    ...         if len(result) != nr_trees:
+    ...             print("Wrong nr of trees:", len(result))
+    ...         elif trees is None:
+    ...             trees = result
+    ...         elif result != trees:
+    ...             print("Trees differ for parser:", P.__name__)
+
+The demo grammar from before, with an ambiguous sentence.
+
+    >>> isawjohn = nltk.parse.featurechart.demo_grammar()
+    >>> unittest(isawjohn, "I saw John with a dog with my cookie", 5)
+
+This grammar tests that variables in different grammar rules are renamed
+before unification. (The problematic variable is in this case ?X).
+
+    >>> whatwasthat = nltk.grammar.FeatureGrammar.fromstring('''
+    ... S[] -> NP[num=?N] VP[num=?N, slash=?X]
+    ... NP[num=?X] -> "what"
+    ... NP[num=?X] -> "that"
+    ... VP[num=?P, slash=none] -> V[num=?P] NP[]
+    ... V[num=sg] -> "was"
+    ... ''')
+    >>> unittest(whatwasthat, "what was that", 1)
+
+This grammar tests that the same rule can be used in different places
+in another rule, and that the variables are properly renamed.
+
+    >>> thislovesthat = nltk.grammar.FeatureGrammar.fromstring('''
+    ... S[] -> NP[case=nom] V[] NP[case=acc]
+    ... NP[case=?X] -> Pron[case=?X]
+    ... Pron[] -> "this"
+    ... Pron[] -> "that"
+    ... V[] -> "loves"
+    ... ''')
+    >>> unittest(thislovesthat, "this loves that", 1)
+
+
+Tests for loading feature grammar files
+---------------------------------------
+
+Alternative 1: first load the grammar, then create the parser.
+
+    >>> fcfg = nltk.data.load('grammars/book_grammars/feat0.fcfg')
+    >>> fcp1 = nltk.parse.FeatureChartParser(fcfg)
+    >>> print((type(fcp1)))
+    <class 'nltk.parse.featurechart.FeatureChartParser'>
+
+Alternative 2: directly load the parser.
+
+    >>> fcp2 = nltk.parse.load_parser('grammars/book_grammars/feat0.fcfg')
+    >>> print((type(fcp2)))
+    <class 'nltk.parse.featurechart.FeatureChartParser'>

venv/lib/python3.10/site-packages/nltk/test/unit/lm/test_counter.py

@@ -0,0 +1,116 @@
+# Natural Language Toolkit: Language Model Unit Tests
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ilia Kurenkov <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import unittest
+
+import pytest
+
+from nltk import FreqDist
+from nltk.lm import NgramCounter
+from nltk.util import everygrams
+
+
+class TestNgramCounter:
+    """Tests for NgramCounter that only involve lookup, no modification."""
+
+    @classmethod
+    def setup_class(self):
+        text = [list("abcd"), list("egdbe")]
+        self.trigram_counter = NgramCounter(
+            everygrams(sent, max_len=3) for sent in text
+        )
+        self.bigram_counter = NgramCounter(everygrams(sent, max_len=2) for sent in text)
+        self.case = unittest.TestCase()
+
+    def test_N(self):
+        assert self.bigram_counter.N() == 16
+        assert self.trigram_counter.N() == 21
+
+    def test_counter_len_changes_with_lookup(self):
+        assert len(self.bigram_counter) == 2
+        self.bigram_counter[50]
+        assert len(self.bigram_counter) == 3
+
+    def test_ngram_order_access_unigrams(self):
+        assert self.bigram_counter[1] == self.bigram_counter.unigrams
+
+    def test_ngram_conditional_freqdist(self):
+        case = unittest.TestCase()
+        expected_trigram_contexts = [
+            ("a", "b"),
+            ("b", "c"),
+            ("e", "g"),
+            ("g", "d"),
+            ("d", "b"),
+        ]
+        expected_bigram_contexts = [("a",), ("b",), ("d",), ("e",), ("c",), ("g",)]
+
+        bigrams = self.trigram_counter[2]
+        trigrams = self.trigram_counter[3]
+
+        self.case.assertCountEqual(expected_bigram_contexts, bigrams.conditions())
+        self.case.assertCountEqual(expected_trigram_contexts, trigrams.conditions())
+
+    def test_bigram_counts_seen_ngrams(self):
+        assert self.bigram_counter[["a"]]["b"] == 1
+        assert self.bigram_counter[["b"]]["c"] == 1
+
+    def test_bigram_counts_unseen_ngrams(self):
+        assert self.bigram_counter[["b"]]["z"] == 0
+
+    def test_unigram_counts_seen_words(self):
+        assert self.bigram_counter["b"] == 2
+
+    def test_unigram_counts_completely_unseen_words(self):
+        assert self.bigram_counter["z"] == 0
+
+
+class TestNgramCounterTraining:
+    @classmethod
+    def setup_class(self):
+        self.counter = NgramCounter()
+        self.case = unittest.TestCase()
+
+    @pytest.mark.parametrize("case", ["", [], None])
+    def test_empty_inputs(self, case):
+        test = NgramCounter(case)
+        assert 2 not in test
+        assert test[1] == FreqDist()
+
+    def test_train_on_unigrams(self):
+        words = list("abcd")
+        counter = NgramCounter([[(w,) for w in words]])
+
+        assert not counter[3]
+        assert not counter[2]
+        self.case.assertCountEqual(words, counter[1].keys())
+
+    def test_train_on_illegal_sentences(self):
+        str_sent = ["Check", "this", "out", "!"]
+        list_sent = [["Check", "this"], ["this", "out"], ["out", "!"]]
+
+        with pytest.raises(TypeError):
+            NgramCounter([str_sent])
+
+        with pytest.raises(TypeError):
+            NgramCounter([list_sent])
+
+    def test_train_on_bigrams(self):
+        bigram_sent = [("a", "b"), ("c", "d")]
+        counter = NgramCounter([bigram_sent])
+        assert not bool(counter[3])
+
+    def test_train_on_mix(self):
+        mixed_sent = [("a", "b"), ("c", "d"), ("e", "f", "g"), ("h",)]
+        counter = NgramCounter([mixed_sent])
+        unigrams = ["h"]
+        bigram_contexts = [("a",), ("c",)]
+        trigram_contexts = [("e", "f")]
+
+        self.case.assertCountEqual(unigrams, counter[1].keys())
+        self.case.assertCountEqual(bigram_contexts, counter[2].keys())
+        self.case.assertCountEqual(trigram_contexts, counter[3].keys())

venv/lib/python3.10/site-packages/nltk/test/unit/lm/test_models.py

@@ -0,0 +1,610 @@
+# Natural Language Toolkit: Language Model Unit Tests
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ilia Kurenkov <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+import math
+from operator import itemgetter
+
+import pytest
+
+from nltk.lm import (
+    MLE,
+    AbsoluteDiscountingInterpolated,
+    KneserNeyInterpolated,
+    Laplace,
+    Lidstone,
+    StupidBackoff,
+    Vocabulary,
+    WittenBellInterpolated,
+)
+from nltk.lm.preprocessing import padded_everygrams
+
+
+@pytest.fixture(scope="session")
+def vocabulary():
+    return Vocabulary(["a", "b", "c", "d", "z", "<s>", "</s>"], unk_cutoff=1)
+
+
+@pytest.fixture(scope="session")
+def training_data():
+    return [["a", "b", "c", "d"], ["e", "g", "a", "d", "b", "e"]]
+
+
+@pytest.fixture(scope="session")
+def bigram_training_data(training_data):
+    return [list(padded_everygrams(2, sent)) for sent in training_data]
+
+
+@pytest.fixture(scope="session")
+def trigram_training_data(training_data):
+    return [list(padded_everygrams(3, sent)) for sent in training_data]
+
+
+@pytest.fixture
+def mle_bigram_model(vocabulary, bigram_training_data):
+    model = MLE(2, vocabulary=vocabulary)
+    model.fit(bigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        ("d", ["c"], 1),
+        # Unseen ngrams should yield 0
+        ("d", ["e"], 0),
+        # Unigrams should also be 0
+        ("z", None, 0),
+        # N unigrams = 14
+        # count('a') = 2
+        ("a", None, 2.0 / 14),
+        # count('y') = 3
+        ("y", None, 3.0 / 14),
+    ],
+)
+def test_mle_bigram_scores(mle_bigram_model, word, context, expected_score):
+    assert pytest.approx(mle_bigram_model.score(word, context), 1e-4) == expected_score
+
+
+def test_mle_bigram_logscore_for_zero_score(mle_bigram_model):
+    assert math.isinf(mle_bigram_model.logscore("d", ["e"]))
+
+
+def test_mle_bigram_entropy_perplexity_seen(mle_bigram_model):
+    # ngrams seen during training
+    trained = [
+        ("<s>", "a"),
+        ("a", "b"),
+        ("b", "<UNK>"),
+        ("<UNK>", "a"),
+        ("a", "d"),
+        ("d", "</s>"),
+    ]
+    # Ngram = Log score
+    # <s>, a    = -1
+    # a, b      = -1
+    # b, UNK    = -1
+    # UNK, a    = -1.585
+    # a, d      = -1
+    # d, </s>   = -1
+    # TOTAL logscores   = -6.585
+    # - AVG logscores   = 1.0975
+    H = 1.0975
+    perplexity = 2.1398
+    assert pytest.approx(mle_bigram_model.entropy(trained), 1e-4) == H
+    assert pytest.approx(mle_bigram_model.perplexity(trained), 1e-4) == perplexity
+
+
+def test_mle_bigram_entropy_perplexity_unseen(mle_bigram_model):
+    # In MLE, even one unseen ngram should make entropy and perplexity infinite
+    untrained = [("<s>", "a"), ("a", "c"), ("c", "d"), ("d", "</s>")]
+
+    assert math.isinf(mle_bigram_model.entropy(untrained))
+    assert math.isinf(mle_bigram_model.perplexity(untrained))
+
+
+def test_mle_bigram_entropy_perplexity_unigrams(mle_bigram_model):
+    # word = score, log score
+    # <s>   = 0.1429, -2.8074
+    # a     = 0.1429, -2.8074
+    # c     = 0.0714, -3.8073
+    # UNK   = 0.2143, -2.2224
+    # d     = 0.1429, -2.8074
+    # c     = 0.0714, -3.8073
+    # </s>  = 0.1429, -2.8074
+    # TOTAL logscores = -21.6243
+    # - AVG logscores = 3.0095
+    H = 3.0095
+    perplexity = 8.0529
+
+    text = [("<s>",), ("a",), ("c",), ("-",), ("d",), ("c",), ("</s>",)]
+
+    assert pytest.approx(mle_bigram_model.entropy(text), 1e-4) == H
+    assert pytest.approx(mle_bigram_model.perplexity(text), 1e-4) == perplexity
+
+
+@pytest.fixture
+def mle_trigram_model(trigram_training_data, vocabulary):
+    model = MLE(order=3, vocabulary=vocabulary)
+    model.fit(trigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # count(d | b, c) = 1
+        # count(b, c) = 1
+        ("d", ("b", "c"), 1),
+        # count(d | c) = 1
+        # count(c) = 1
+        ("d", ["c"], 1),
+        # total number of tokens is 18, of which "a" occurred 2 times
+        ("a", None, 2.0 / 18),
+        # in vocabulary but unseen
+        ("z", None, 0),
+        # out of vocabulary should use "UNK" score
+        ("y", None, 3.0 / 18),
+    ],
+)
+def test_mle_trigram_scores(mle_trigram_model, word, context, expected_score):
+    assert pytest.approx(mle_trigram_model.score(word, context), 1e-4) == expected_score
+
+
+@pytest.fixture
+def lidstone_bigram_model(bigram_training_data, vocabulary):
+    model = Lidstone(0.1, order=2, vocabulary=vocabulary)
+    model.fit(bigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # count(d | c) = 1
+        # *count(d | c) = 1.1
+        # Count(w | c for w in vocab) = 1
+        # *Count(w | c for w in vocab) = 1.8
+        ("d", ["c"], 1.1 / 1.8),
+        # Total unigrams: 14
+        # Vocab size: 8
+        # Denominator: 14 + 0.8 = 14.8
+        # count("a") = 2
+        # *count("a") = 2.1
+        ("a", None, 2.1 / 14.8),
+        # in vocabulary but unseen
+        # count("z") = 0
+        # *count("z") = 0.1
+        ("z", None, 0.1 / 14.8),
+        # out of vocabulary should use "UNK" score
+        # count("<UNK>") = 3
+        # *count("<UNK>") = 3.1
+        ("y", None, 3.1 / 14.8),
+    ],
+)
+def test_lidstone_bigram_score(lidstone_bigram_model, word, context, expected_score):
+    assert (
+        pytest.approx(lidstone_bigram_model.score(word, context), 1e-4)
+        == expected_score
+    )
+
+
+def test_lidstone_entropy_perplexity(lidstone_bigram_model):
+    text = [
+        ("<s>", "a"),
+        ("a", "c"),
+        ("c", "<UNK>"),
+        ("<UNK>", "d"),
+        ("d", "c"),
+        ("c", "</s>"),
+    ]
+    # Unlike MLE this should be able to handle completely novel ngrams
+    # Ngram = score, log score
+    # <s>, a    = 0.3929, -1.3479
+    # a, c      = 0.0357, -4.8074
+    # c, UNK    = 0.0(5), -4.1699
+    # UNK, d    = 0.0263,  -5.2479
+    # d, c      = 0.0357, -4.8074
+    # c, </s>   = 0.0(5), -4.1699
+    # TOTAL logscore: −24.5504
+    # - AVG logscore: 4.0917
+    H = 4.0917
+    perplexity = 17.0504
+    assert pytest.approx(lidstone_bigram_model.entropy(text), 1e-4) == H
+    assert pytest.approx(lidstone_bigram_model.perplexity(text), 1e-4) == perplexity
+
+
+@pytest.fixture
+def lidstone_trigram_model(trigram_training_data, vocabulary):
+    model = Lidstone(0.1, order=3, vocabulary=vocabulary)
+    model.fit(trigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # Logic behind this is the same as for bigram model
+        ("d", ["c"], 1.1 / 1.8),
+        # if we choose a word that hasn't appeared after (b, c)
+        ("e", ["c"], 0.1 / 1.8),
+        # Trigram score now
+        ("d", ["b", "c"], 1.1 / 1.8),
+        ("e", ["b", "c"], 0.1 / 1.8),
+    ],
+)
+def test_lidstone_trigram_score(lidstone_trigram_model, word, context, expected_score):
+    assert (
+        pytest.approx(lidstone_trigram_model.score(word, context), 1e-4)
+        == expected_score
+    )
+
+
+@pytest.fixture
+def laplace_bigram_model(bigram_training_data, vocabulary):
+    model = Laplace(2, vocabulary=vocabulary)
+    model.fit(bigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # basic sanity-check:
+        # count(d | c) = 1
+        # *count(d | c) = 2
+        # Count(w | c for w in vocab) = 1
+        # *Count(w | c for w in vocab) = 9
+        ("d", ["c"], 2.0 / 9),
+        # Total unigrams: 14
+        # Vocab size: 8
+        # Denominator: 14 + 8 = 22
+        # count("a") = 2
+        # *count("a") = 3
+        ("a", None, 3.0 / 22),
+        # in vocabulary but unseen
+        # count("z") = 0
+        # *count("z") = 1
+        ("z", None, 1.0 / 22),
+        # out of vocabulary should use "UNK" score
+        # count("<UNK>") = 3
+        # *count("<UNK>") = 4
+        ("y", None, 4.0 / 22),
+    ],
+)
+def test_laplace_bigram_score(laplace_bigram_model, word, context, expected_score):
+    assert (
+        pytest.approx(laplace_bigram_model.score(word, context), 1e-4) == expected_score
+    )
+
+
+def test_laplace_bigram_entropy_perplexity(laplace_bigram_model):
+    text = [
+        ("<s>", "a"),
+        ("a", "c"),
+        ("c", "<UNK>"),
+        ("<UNK>", "d"),
+        ("d", "c"),
+        ("c", "</s>"),
+    ]
+    # Unlike MLE this should be able to handle completely novel ngrams
+    # Ngram = score, log score
+    # <s>, a    = 0.2, -2.3219
+    # a, c      = 0.1, -3.3219
+    # c, UNK    = 0.(1), -3.1699
+    # UNK, d    = 0.(09), 3.4594
+    # d, c      = 0.1 -3.3219
+    # c, </s>   = 0.(1), -3.1699
+    # Total logscores: −18.7651
+    # - AVG logscores: 3.1275
+    H = 3.1275
+    perplexity = 8.7393
+    assert pytest.approx(laplace_bigram_model.entropy(text), 1e-4) == H
+    assert pytest.approx(laplace_bigram_model.perplexity(text), 1e-4) == perplexity
+
+
+def test_laplace_gamma(laplace_bigram_model):
+    assert laplace_bigram_model.gamma == 1
+
+
+@pytest.fixture
+def wittenbell_trigram_model(trigram_training_data, vocabulary):
+    model = WittenBellInterpolated(3, vocabulary=vocabulary)
+    model.fit(trigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # For unigram scores by default revert to regular MLE
+        # Total unigrams: 18
+        # Vocab Size = 7
+        # count('c'): 1
+        ("c", None, 1.0 / 18),
+        # in vocabulary but unseen
+        # count("z") = 0
+        ("z", None, 0 / 18),
+        # out of vocabulary should use "UNK" score
+        # count("<UNK>") = 3
+        ("y", None, 3.0 / 18),
+        # 2 words follow b and b occurred a total of 2 times
+        # gamma(['b']) = 2 / (2 + 2) = 0.5
+        # mle.score('c', ['b']) = 0.5
+        # mle('c') = 1 / 18 = 0.055
+        # (1 - gamma) * mle + gamma * mle('c') ~= 0.27 + 0.055
+        ("c", ["b"], (1 - 0.5) * 0.5 + 0.5 * 1 / 18),
+        # building on that, let's try 'a b c' as the trigram
+        # 1 word follows 'a b' and 'a b' occurred 1 time
+        # gamma(['a', 'b']) = 1 / (1 + 1) = 0.5
+        # mle("c", ["a", "b"]) = 1
+        ("c", ["a", "b"], (1 - 0.5) + 0.5 * ((1 - 0.5) * 0.5 + 0.5 * 1 / 18)),
+        # P(c|zb)
+        # The ngram 'zbc' was not seen, so we use P(c|b). See issue #2332.
+        ("c", ["z", "b"], ((1 - 0.5) * 0.5 + 0.5 * 1 / 18)),
+    ],
+)
+def test_wittenbell_trigram_score(
+    wittenbell_trigram_model, word, context, expected_score
+):
+    assert (
+        pytest.approx(wittenbell_trigram_model.score(word, context), 1e-4)
+        == expected_score
+    )
+
+
+###############################################################################
+#                              Notation Explained                             #
+###############################################################################
+# For all subsequent calculations we use the following notation:
+# 1. '*': Placeholder for any word/character. E.g. '*b' stands for
+#    all bigrams that end in 'b'. '*b*' stands for all trigrams that
+#    contain 'b' in the middle.
+# 1. count(ngram): Count all instances (tokens) of an ngram.
+# 1. unique(ngram): Count unique instances (types) of an ngram.
+
+
+@pytest.fixture
+def kneserney_trigram_model(trigram_training_data, vocabulary):
+    model = KneserNeyInterpolated(order=3, discount=0.75, vocabulary=vocabulary)
+    model.fit(trigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # P(c) = count('*c') / unique('**')
+        #      = 1 / 14
+        ("c", None, 1.0 / 14),
+        # P(z) = count('*z') / unique('**')
+        #      = 0 / 14
+        # 'z' is in the vocabulary, but it was not seen during training.
+        ("z", None, 0.0 / 14),
+        # P(y)
+        # Out of vocabulary should use "UNK" score.
+        # P(y) = P(UNK) = count('*UNK') / unique('**')
+        ("y", None, 3 / 14),
+        # We start with P(c|b)
+        # P(c|b) = alpha('bc') + gamma('b') * P(c)
+        # alpha('bc') = max(unique('*bc') - discount, 0) / unique('*b*')
+        #             = max(1 - 0.75, 0) / 2
+        #             = 0.125
+        # gamma('b')  = discount * unique('b*') / unique('*b*')
+        #             = (0.75 * 2) / 2
+        #             = 0.75
+        ("c", ["b"], (0.125 + 0.75 * (1 / 14))),
+        # Building on that, let's try P(c|ab).
+        # P(c|ab) = alpha('abc') + gamma('ab') * P(c|b)
+        # alpha('abc') = max(count('abc') - discount, 0) / count('ab*')
+        #              = max(1 - 0.75, 0) / 1
+        #              = 0.25
+        # gamma('ab')  = (discount * unique('ab*')) / count('ab*')
+        #              = 0.75 * 1 / 1
+        ("c", ["a", "b"], 0.25 + 0.75 * (0.125 + 0.75 * (1 / 14))),
+        # P(c|zb)
+        # The ngram 'zbc' was not seen, so we use P(c|b). See issue #2332.
+        ("c", ["z", "b"], (0.125 + 0.75 * (1 / 14))),
+    ],
+)
+def test_kneserney_trigram_score(
+    kneserney_trigram_model, word, context, expected_score
+):
+    assert (
+        pytest.approx(kneserney_trigram_model.score(word, context), 1e-4)
+        == expected_score
+    )
+
+
+@pytest.fixture
+def absolute_discounting_trigram_model(trigram_training_data, vocabulary):
+    model = AbsoluteDiscountingInterpolated(order=3, vocabulary=vocabulary)
+    model.fit(trigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # For unigram scores revert to uniform
+        # P(c) = count('c') / count('**')
+        ("c", None, 1.0 / 18),
+        # in vocabulary but unseen
+        # count('z') = 0
+        ("z", None, 0.0 / 18),
+        # out of vocabulary should use "UNK" score
+        # count('<UNK>') = 3
+        ("y", None, 3 / 18),
+        # P(c|b) = alpha('bc') + gamma('b') * P(c)
+        # alpha('bc') = max(count('bc') - discount, 0) / count('b*')
+        #             = max(1 - 0.75, 0) / 2
+        #             = 0.125
+        # gamma('b')  = discount * unique('b*') / count('b*')
+        #             = (0.75 * 2) / 2
+        #             = 0.75
+        ("c", ["b"], (0.125 + 0.75 * (2 / 2) * (1 / 18))),
+        # Building on that, let's try P(c|ab).
+        # P(c|ab) = alpha('abc') + gamma('ab') * P(c|b)
+        # alpha('abc') = max(count('abc') - discount, 0) / count('ab*')
+        #              = max(1 - 0.75, 0) / 1
+        #              = 0.25
+        # gamma('ab')  = (discount * unique('ab*')) / count('ab*')
+        #              = 0.75 * 1 / 1
+        ("c", ["a", "b"], 0.25 + 0.75 * (0.125 + 0.75 * (2 / 2) * (1 / 18))),
+        # P(c|zb)
+        # The ngram 'zbc' was not seen, so we use P(c|b). See issue #2332.
+        ("c", ["z", "b"], (0.125 + 0.75 * (2 / 2) * (1 / 18))),
+    ],
+)
+def test_absolute_discounting_trigram_score(
+    absolute_discounting_trigram_model, word, context, expected_score
+):
+    assert (
+        pytest.approx(absolute_discounting_trigram_model.score(word, context), 1e-4)
+        == expected_score
+    )
+
+
+@pytest.fixture
+def stupid_backoff_trigram_model(trigram_training_data, vocabulary):
+    model = StupidBackoff(order=3, vocabulary=vocabulary)
+    model.fit(trigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "word, context, expected_score",
+    [
+        # For unigram scores revert to uniform
+        # total bigrams = 18
+        ("c", None, 1.0 / 18),
+        # in vocabulary but unseen
+        # bigrams ending with z = 0
+        ("z", None, 0.0 / 18),
+        # out of vocabulary should use "UNK" score
+        # count('<UNK>'): 3
+        ("y", None, 3 / 18),
+        # c follows 1 time out of 2 after b
+        ("c", ["b"], 1 / 2),
+        # c always follows ab
+        ("c", ["a", "b"], 1 / 1),
+        # The ngram 'z b c' was not seen, so we backoff to
+        # the score of the ngram 'b c' * smoothing factor
+        ("c", ["z", "b"], (0.4 * (1 / 2))),
+    ],
+)
+def test_stupid_backoff_trigram_score(
+    stupid_backoff_trigram_model, word, context, expected_score
+):
+    assert (
+        pytest.approx(stupid_backoff_trigram_model.score(word, context), 1e-4)
+        == expected_score
+    )
+
+
+###############################################################################
+#               Probability Distributions Should Sum up to Unity              #
+###############################################################################
+
+
+@pytest.fixture(scope="session")
+def kneserney_bigram_model(bigram_training_data, vocabulary):
+    model = KneserNeyInterpolated(order=2, vocabulary=vocabulary)
+    model.fit(bigram_training_data)
+    return model
+
+
+@pytest.mark.parametrize(
+    "model_fixture",
+    [
+        "mle_bigram_model",
+        "mle_trigram_model",
+        "lidstone_bigram_model",
+        "laplace_bigram_model",
+        "wittenbell_trigram_model",
+        "absolute_discounting_trigram_model",
+        "kneserney_bigram_model",
+        pytest.param(
+            "stupid_backoff_trigram_model",
+            marks=pytest.mark.xfail(
+                reason="Stupid Backoff is not a valid distribution"
+            ),
+        ),
+    ],
+)
+@pytest.mark.parametrize(
+    "context",
+    [("a",), ("c",), ("<s>",), ("b",), ("<UNK>",), ("d",), ("e",), ("r",), ("w",)],
+    ids=itemgetter(0),
+)
+def test_sums_to_1(model_fixture, context, request):
+    model = request.getfixturevalue(model_fixture)
+    scores_for_context = sum(model.score(w, context) for w in model.vocab)
+    assert pytest.approx(scores_for_context, 1e-7) == 1.0
+
+
+###############################################################################
+#                               Generating Text                               #
+###############################################################################
+
+
+def test_generate_one_no_context(mle_trigram_model):
+    assert mle_trigram_model.generate(random_seed=3) == "<UNK>"
+
+
+def test_generate_one_from_limiting_context(mle_trigram_model):
+    # We don't need random_seed for contexts with only one continuation
+    assert mle_trigram_model.generate(text_seed=["c"]) == "d"
+    assert mle_trigram_model.generate(text_seed=["b", "c"]) == "d"
+    assert mle_trigram_model.generate(text_seed=["a", "c"]) == "d"
+
+
+def test_generate_one_from_varied_context(mle_trigram_model):
+    # When context doesn't limit our options enough, seed the random choice
+    assert mle_trigram_model.generate(text_seed=("a", "<s>"), random_seed=2) == "a"
+
+
+def test_generate_cycle(mle_trigram_model):
+    # Add a cycle to the model: bd -> b, db -> d
+    more_training_text = [padded_everygrams(mle_trigram_model.order, list("bdbdbd"))]
+
+    mle_trigram_model.fit(more_training_text)
+    # Test that we can escape the cycle
+    assert mle_trigram_model.generate(7, text_seed=("b", "d"), random_seed=5) == [
+        "b",
+        "d",
+        "b",
+        "d",
+        "b",
+        "d",
+        "</s>",
+    ]
+
+
+def test_generate_with_text_seed(mle_trigram_model):
+    assert mle_trigram_model.generate(5, text_seed=("<s>", "e"), random_seed=3) == [
+        "<UNK>",
+        "a",
+        "d",
+        "b",
+        "<UNK>",
+    ]
+
+
+def test_generate_oov_text_seed(mle_trigram_model):
+    assert mle_trigram_model.generate(
+        text_seed=("aliens",), random_seed=3
+    ) == mle_trigram_model.generate(text_seed=("<UNK>",), random_seed=3)
+
+
+def test_generate_None_text_seed(mle_trigram_model):
+    # should crash with type error when we try to look it up in vocabulary
+    with pytest.raises(TypeError):
+        mle_trigram_model.generate(text_seed=(None,))
+
+    # This will work
+    assert mle_trigram_model.generate(
+        text_seed=None, random_seed=3
+    ) == mle_trigram_model.generate(random_seed=3)

venv/lib/python3.10/site-packages/nltk/test/unit/lm/test_preprocessing.py

@@ -0,0 +1,30 @@
+# Natural Language Toolkit: Language Model Unit Tests
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ilia Kurenkov <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+import unittest
+
+from nltk.lm.preprocessing import padded_everygram_pipeline
+
+
+class TestPreprocessing(unittest.TestCase):
+    def test_padded_everygram_pipeline(self):
+        expected_train = [
+            [
+                ("<s>",),
+                ("<s>", "a"),
+                ("a",),
+                ("a", "b"),
+                ("b",),
+                ("b", "c"),
+                ("c",),
+                ("c", "</s>"),
+                ("</s>",),
+            ]
+        ]
+        expected_vocab = ["<s>", "a", "b", "c", "</s>"]
+        train_data, vocab_data = padded_everygram_pipeline(2, [["a", "b", "c"]])
+        self.assertEqual([list(sent) for sent in train_data], expected_train)
+        self.assertEqual(list(vocab_data), expected_vocab)

venv/lib/python3.10/site-packages/nltk/test/unit/lm/test_vocabulary.py

@@ -0,0 +1,156 @@
+# Natural Language Toolkit: Language Model Unit Tests
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Ilia Kurenkov <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+import unittest
+from collections import Counter
+from timeit import timeit
+
+from nltk.lm import Vocabulary
+
+
+class NgramModelVocabularyTests(unittest.TestCase):
+    """tests Vocabulary Class"""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.vocab = Vocabulary(
+            ["z", "a", "b", "c", "f", "d", "e", "g", "a", "d", "b", "e", "w"],
+            unk_cutoff=2,
+        )
+
+    def test_truthiness(self):
+        self.assertTrue(self.vocab)
+
+    def test_cutoff_value_set_correctly(self):
+        self.assertEqual(self.vocab.cutoff, 2)
+
+    def test_unable_to_change_cutoff(self):
+        with self.assertRaises(AttributeError):
+            self.vocab.cutoff = 3
+
+    def test_cutoff_setter_checks_value(self):
+        with self.assertRaises(ValueError) as exc_info:
+            Vocabulary("abc", unk_cutoff=0)
+        expected_error_msg = "Cutoff value cannot be less than 1. Got: 0"
+        self.assertEqual(expected_error_msg, str(exc_info.exception))
+
+    def test_counts_set_correctly(self):
+        self.assertEqual(self.vocab.counts["a"], 2)
+        self.assertEqual(self.vocab.counts["b"], 2)
+        self.assertEqual(self.vocab.counts["c"], 1)
+
+    def test_membership_check_respects_cutoff(self):
+        # a was seen 2 times, so it should be considered part of the vocabulary
+        self.assertTrue("a" in self.vocab)
+        # "c" was seen once, it shouldn't be considered part of the vocab
+        self.assertFalse("c" in self.vocab)
+        # "z" was never seen at all, also shouldn't be considered in the vocab
+        self.assertFalse("z" in self.vocab)
+
+    def test_vocab_len_respects_cutoff(self):
+        # Vocab size is the number of unique tokens that occur at least as often
+        # as the cutoff value, plus 1 to account for unknown words.
+        self.assertEqual(5, len(self.vocab))
+
+    def test_vocab_iter_respects_cutoff(self):
+        vocab_counts = ["a", "b", "c", "d", "e", "f", "g", "w", "z"]
+        vocab_items = ["a", "b", "d", "e", "<UNK>"]
+
+        self.assertCountEqual(vocab_counts, list(self.vocab.counts.keys()))
+        self.assertCountEqual(vocab_items, list(self.vocab))
+
+    def test_update_empty_vocab(self):
+        empty = Vocabulary(unk_cutoff=2)
+        self.assertEqual(len(empty), 0)
+        self.assertFalse(empty)
+        self.assertIn(empty.unk_label, empty)
+
+        empty.update(list("abcde"))
+        self.assertIn(empty.unk_label, empty)
+
+    def test_lookup(self):
+        self.assertEqual(self.vocab.lookup("a"), "a")
+        self.assertEqual(self.vocab.lookup("c"), "<UNK>")
+
+    def test_lookup_iterables(self):
+        self.assertEqual(self.vocab.lookup(["a", "b"]), ("a", "b"))
+        self.assertEqual(self.vocab.lookup(("a", "b")), ("a", "b"))
+        self.assertEqual(self.vocab.lookup(("a", "c")), ("a", "<UNK>"))
+        self.assertEqual(
+            self.vocab.lookup(map(str, range(3))), ("<UNK>", "<UNK>", "<UNK>")
+        )
+
+    def test_lookup_empty_iterables(self):
+        self.assertEqual(self.vocab.lookup(()), ())
+        self.assertEqual(self.vocab.lookup([]), ())
+        self.assertEqual(self.vocab.lookup(iter([])), ())
+        self.assertEqual(self.vocab.lookup(n for n in range(0, 0)), ())
+
+    def test_lookup_recursive(self):
+        self.assertEqual(
+            self.vocab.lookup([["a", "b"], ["a", "c"]]), (("a", "b"), ("a", "<UNK>"))
+        )
+        self.assertEqual(self.vocab.lookup([["a", "b"], "c"]), (("a", "b"), "<UNK>"))
+        self.assertEqual(self.vocab.lookup([[[[["a", "b"]]]]]), ((((("a", "b"),),),),))
+
+    def test_lookup_None(self):
+        with self.assertRaises(TypeError):
+            self.vocab.lookup(None)
+        with self.assertRaises(TypeError):
+            list(self.vocab.lookup([None, None]))
+
+    def test_lookup_int(self):
+        with self.assertRaises(TypeError):
+            self.vocab.lookup(1)
+        with self.assertRaises(TypeError):
+            list(self.vocab.lookup([1, 2]))
+
+    def test_lookup_empty_str(self):
+        self.assertEqual(self.vocab.lookup(""), "<UNK>")
+
+    def test_eqality(self):
+        v1 = Vocabulary(["a", "b", "c"], unk_cutoff=1)
+        v2 = Vocabulary(["a", "b", "c"], unk_cutoff=1)
+        v3 = Vocabulary(["a", "b", "c"], unk_cutoff=1, unk_label="blah")
+        v4 = Vocabulary(["a", "b"], unk_cutoff=1)
+
+        self.assertEqual(v1, v2)
+        self.assertNotEqual(v1, v3)
+        self.assertNotEqual(v1, v4)
+
+    def test_str(self):
+        self.assertEqual(
+            str(self.vocab), "<Vocabulary with cutoff=2 unk_label='<UNK>' and 5 items>"
+        )
+
+    def test_creation_with_counter(self):
+        self.assertEqual(
+            self.vocab,
+            Vocabulary(
+                Counter(
+                    ["z", "a", "b", "c", "f", "d", "e", "g", "a", "d", "b", "e", "w"]
+                ),
+                unk_cutoff=2,
+            ),
+        )
+
+    @unittest.skip(
+        reason="Test is known to be flaky as it compares (runtime) performance."
+    )
+    def test_len_is_constant(self):
+        # Given an obviously small and an obviously large vocabulary.
+        small_vocab = Vocabulary("abcde")
+        from nltk.corpus.europarl_raw import english
+
+        large_vocab = Vocabulary(english.words())
+
+        # If we time calling `len` on them.
+        small_vocab_len_time = timeit("len(small_vocab)", globals=locals())
+        large_vocab_len_time = timeit("len(large_vocab)", globals=locals())
+
+        # The timing should be the same order of magnitude.
+        self.assertAlmostEqual(small_vocab_len_time, large_vocab_len_time, places=1)

venv/lib/python3.10/site-packages/nltk/test/unit/test_aline.py

@@ -0,0 +1,48 @@
+"""
+Test Aline algorithm for aligning phonetic sequences
+"""
+from nltk.metrics import aline
+
+
+def test_aline():
+    result = aline.align("θin", "tenwis")
+    expected = [[("θ", "t"), ("i", "e"), ("n", "n")]]
+
+    assert result == expected
+
+    result = aline.align("jo", "ʒə")
+    expected = [[("j", "ʒ"), ("o", "ə")]]
+
+    assert result == expected
+
+    result = aline.align("pematesiweni", "pematesewen")
+    expected = [
+        [
+            ("p", "p"),
+            ("e", "e"),
+            ("m", "m"),
+            ("a", "a"),
+            ("t", "t"),
+            ("e", "e"),
+            ("s", "s"),
+            ("i", "e"),
+            ("w", "w"),
+            ("e", "e"),
+            ("n", "n"),
+        ]
+    ]
+
+    assert result == expected
+
+    result = aline.align("tuwθ", "dentis")
+    expected = [[("t", "t"), ("u", "i"), ("w", "-"), ("θ", "s")]]
+
+    assert result == expected
+
+
+def test_aline_delta():
+    """
+    Test aline for computing the difference between two segments
+    """
+    assert aline.delta("p", "q") == 20.0
+    assert aline.delta("a", "A") == 0.0

venv/lib/python3.10/site-packages/nltk/test/unit/test_bllip.py

@@ -0,0 +1,42 @@
+import pytest
+
+from nltk.data import find
+from nltk.parse.bllip import BllipParser
+from nltk.tree import Tree
+
+
+@pytest.fixture(scope="module")
+def parser():
+    model_dir = find("models/bllip_wsj_no_aux").path
+    return BllipParser.from_unified_model_dir(model_dir)
+
+
+def setup_module():
+    pytest.importorskip("bllipparser")
+
+
+class TestBllipParser:
+    def test_parser_loads_a_valid_tree(self, parser):
+        parsed = parser.parse("I saw the man with the telescope")
+        tree = next(parsed)
+
+        assert isinstance(tree, Tree)
+        assert (
+            tree.pformat()
+            == """
+(S1
+  (S
+    (NP (PRP I))
+    (VP
+      (VBD saw)
+      (NP (DT the) (NN man))
+      (PP (IN with) (NP (DT the) (NN telescope))))))
+""".strip()
+        )
+
+    def test_tagged_parse_finds_matching_element(self, parser):
+        parsed = parser.parse("I saw the man with the telescope")
+        tagged_tree = next(parser.tagged_parse([("telescope", "NN")]))
+
+        assert isinstance(tagged_tree, Tree)
+        assert tagged_tree.pformat() == "(S1 (NP (NN telescope)))"

venv/lib/python3.10/site-packages/nltk/test/unit/test_brill.py

@@ -0,0 +1,34 @@
+"""
+Tests for Brill tagger.
+"""
+
+import unittest
+
+from nltk.corpus import treebank
+from nltk.tag import UnigramTagger, brill, brill_trainer
+from nltk.tbl import demo
+
+
+class TestBrill(unittest.TestCase):
+    def test_pos_template(self):
+        train_sents = treebank.tagged_sents()[:1000]
+        tagger = UnigramTagger(train_sents)
+        trainer = brill_trainer.BrillTaggerTrainer(
+            tagger, [brill.Template(brill.Pos([-1]))]
+        )
+        brill_tagger = trainer.train(train_sents)
+        # Example from https://github.com/nltk/nltk/issues/769
+        result = brill_tagger.tag("This is a foo bar sentence".split())
+        expected = [
+            ("This", "DT"),
+            ("is", "VBZ"),
+            ("a", "DT"),
+            ("foo", None),
+            ("bar", "NN"),
+            ("sentence", None),
+        ]
+        self.assertEqual(result, expected)
+
+    @unittest.skip("Should be tested in __main__ of nltk.tbl.demo")
+    def test_brill_demo(self):
+        demo()

venv/lib/python3.10/site-packages/nltk/test/unit/test_cfd_mutation.py

@@ -0,0 +1,39 @@
+import unittest
+
+import pytest
+
+from nltk import ConditionalFreqDist, tokenize
+
+
+class TestEmptyCondFreq(unittest.TestCase):
+    def test_tabulate(self):
+        empty = ConditionalFreqDist()
+        self.assertEqual(empty.conditions(), [])
+        with pytest.raises(ValueError):
+            empty.tabulate(conditions="BUG")  # nonexistent keys shouldn't be added
+        self.assertEqual(empty.conditions(), [])
+
+    def test_plot(self):
+        empty = ConditionalFreqDist()
+        self.assertEqual(empty.conditions(), [])
+        empty.plot(conditions=["BUG"])  # nonexistent keys shouldn't be added
+        self.assertEqual(empty.conditions(), [])
+
+    def test_increment(self):
+        # make sure that we can still mutate cfd normally
+        text = "cow cat mouse cat tiger"
+        cfd = ConditionalFreqDist()
+
+        # create cfd with word length as condition
+        for word in tokenize.word_tokenize(text):
+            condition = len(word)
+            cfd[condition][word] += 1
+
+        self.assertEqual(cfd.conditions(), [3, 5])
+
+        # incrementing previously unseen key is still possible
+        cfd[2]["hi"] += 1
+        self.assertCountEqual(cfd.conditions(), [3, 5, 2])  # new condition added
+        self.assertEqual(
+            cfd[2]["hi"], 1
+        )  # key's frequency incremented from 0 (unseen) to 1

venv/lib/python3.10/site-packages/nltk/test/unit/test_cfg2chomsky.py

@@ -0,0 +1,49 @@
+import unittest
+
+import nltk
+from nltk.grammar import CFG
+
+
+class ChomskyNormalFormForCFGTest(unittest.TestCase):
+    def test_simple(self):
+        grammar = CFG.fromstring(
+            """
+          S -> NP VP
+          PP -> P NP
+          NP -> Det N | NP PP P
+          VP -> V NP | VP PP
+          VP -> Det
+          Det -> 'a' | 'the'
+          N -> 'dog' | 'cat'
+          V -> 'chased' | 'sat'
+          P -> 'on' | 'in'
+        """
+        )
+        self.assertFalse(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())
+        grammar = grammar.chomsky_normal_form(flexible=True)
+        self.assertTrue(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())
+
+        grammar2 = CFG.fromstring(
+            """
+          S -> NP VP
+          NP -> VP N P
+          VP -> P
+          N -> 'dog' | 'cat'
+          P -> 'on' | 'in'
+        """
+        )
+        self.assertFalse(grammar2.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar2.is_chomsky_normal_form())
+        grammar2 = grammar2.chomsky_normal_form()
+        self.assertTrue(grammar2.is_flexible_chomsky_normal_form())
+        self.assertTrue(grammar2.is_chomsky_normal_form())
+
+    def test_complex(self):
+        grammar = nltk.data.load("grammars/large_grammars/atis.cfg")
+        self.assertFalse(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())
+        grammar = grammar.chomsky_normal_form(flexible=True)
+        self.assertTrue(grammar.is_flexible_chomsky_normal_form())
+        self.assertFalse(grammar.is_chomsky_normal_form())

venv/lib/python3.10/site-packages/nltk/test/unit/test_chunk.py

@@ -0,0 +1,85 @@
+import unittest
+
+from nltk import RegexpParser
+
+
+class TestChunkRule(unittest.TestCase):
+    def test_tag_pattern2re_pattern_quantifier(self):
+        """Test for bug https://github.com/nltk/nltk/issues/1597
+
+        Ensures that curly bracket quantifiers can be used inside a chunk rule.
+        This type of quantifier has been used for the supplementary example
+        in https://www.nltk.org/book/ch07.html#exploring-text-corpora.
+        """
+        sent = [
+            ("The", "AT"),
+            ("September-October", "NP"),
+            ("term", "NN"),
+            ("jury", "NN"),
+            ("had", "HVD"),
+            ("been", "BEN"),
+            ("charged", "VBN"),
+            ("by", "IN"),
+            ("Fulton", "NP-TL"),
+            ("Superior", "JJ-TL"),
+            ("Court", "NN-TL"),
+            ("Judge", "NN-TL"),
+            ("Durwood", "NP"),
+            ("Pye", "NP"),
+            ("to", "TO"),
+            ("investigate", "VB"),
+            ("reports", "NNS"),
+            ("of", "IN"),
+            ("possible", "JJ"),
+            ("``", "``"),
+            ("irregularities", "NNS"),
+            ("''", "''"),
+            ("in", "IN"),
+            ("the", "AT"),
+            ("hard-fought", "JJ"),
+            ("primary", "NN"),
+            ("which", "WDT"),
+            ("was", "BEDZ"),
+            ("won", "VBN"),
+            ("by", "IN"),
+            ("Mayor-nominate", "NN-TL"),
+            ("Ivan", "NP"),
+            ("Allen", "NP"),
+            ("Jr.", "NP"),
+            (".", "."),
+        ]  # source: brown corpus
+        cp = RegexpParser("CHUNK: {<N.*>{4,}}")
+        tree = cp.parse(sent)
+        assert (
+            tree.pformat()
+            == """(S
+  The/AT
+  September-October/NP
+  term/NN
+  jury/NN
+  had/HVD
+  been/BEN
+  charged/VBN
+  by/IN
+  Fulton/NP-TL
+  Superior/JJ-TL
+  (CHUNK Court/NN-TL Judge/NN-TL Durwood/NP Pye/NP)
+  to/TO
+  investigate/VB
+  reports/NNS
+  of/IN
+  possible/JJ
+  ``/``
+  irregularities/NNS
+  ''/''
+  in/IN
+  the/AT
+  hard-fought/JJ
+  primary/NN
+  which/WDT
+  was/BEDZ
+  won/VBN
+  by/IN
+  (CHUNK Mayor-nominate/NN-TL Ivan/NP Allen/NP Jr./NP)
+  ./.)"""
+        )

venv/lib/python3.10/site-packages/nltk/test/unit/test_classify.py

@@ -0,0 +1,49 @@
+"""
+Unit tests for nltk.classify. See also: nltk/test/classify.doctest
+"""
+import pytest
+
+from nltk import classify
+
+TRAIN = [
+    (dict(a=1, b=1, c=1), "y"),
+    (dict(a=1, b=1, c=1), "x"),
+    (dict(a=1, b=1, c=0), "y"),
+    (dict(a=0, b=1, c=1), "x"),
+    (dict(a=0, b=1, c=1), "y"),
+    (dict(a=0, b=0, c=1), "y"),
+    (dict(a=0, b=1, c=0), "x"),
+    (dict(a=0, b=0, c=0), "x"),
+    (dict(a=0, b=1, c=1), "y"),
+]
+
+TEST = [
+    (dict(a=1, b=0, c=1)),  # unseen
+    (dict(a=1, b=0, c=0)),  # unseen
+    (dict(a=0, b=1, c=1)),  # seen 3 times, labels=y,y,x
+    (dict(a=0, b=1, c=0)),  # seen 1 time, label=x
+]
+
+RESULTS = [(0.16, 0.84), (0.46, 0.54), (0.41, 0.59), (0.76, 0.24)]
+
+
+def assert_classifier_correct(algorithm):
+    try:
+        classifier = classify.MaxentClassifier.train(
+            TRAIN, algorithm, trace=0, max_iter=1000
+        )
+    except (LookupError, AttributeError) as e:
+        pytest.skip(str(e))
+
+    for (px, py), featureset in zip(RESULTS, TEST):
+        pdist = classifier.prob_classify(featureset)
+        assert abs(pdist.prob("x") - px) < 1e-2, (pdist.prob("x"), px)
+        assert abs(pdist.prob("y") - py) < 1e-2, (pdist.prob("y"), py)
+
+
+def test_megam():
+    assert_classifier_correct("MEGAM")
+
+
+def test_tadm():
+    assert_classifier_correct("TADM")

venv/lib/python3.10/site-packages/nltk/test/unit/test_collocations.py

@@ -0,0 +1,120 @@
+from nltk.collocations import BigramCollocationFinder
+from nltk.metrics import BigramAssocMeasures
+
+## Test bigram counters with discontinuous bigrams and repeated words
+
+_EPSILON = 1e-8
+SENT = "this this is is a a test test".split()
+
+
+def close_enough(x, y):
+    """Verify that two sequences of n-gram association values are within
+    _EPSILON of each other.
+    """
+
+    return all(abs(x1[1] - y1[1]) <= _EPSILON for x1, y1 in zip(x, y))
+
+
+def test_bigram2():
+    b = BigramCollocationFinder.from_words(SENT)
+
+    assert sorted(b.ngram_fd.items()) == [
+        (("a", "a"), 1),
+        (("a", "test"), 1),
+        (("is", "a"), 1),
+        (("is", "is"), 1),
+        (("test", "test"), 1),
+        (("this", "is"), 1),
+        (("this", "this"), 1),
+    ]
+    assert sorted(b.word_fd.items()) == [("a", 2), ("is", 2), ("test", 2), ("this", 2)]
+
+    assert len(SENT) == sum(b.word_fd.values()) == sum(b.ngram_fd.values()) + 1
+    assert close_enough(
+        sorted(b.score_ngrams(BigramAssocMeasures.pmi)),
+        [
+            (("a", "a"), 1.0),
+            (("a", "test"), 1.0),
+            (("is", "a"), 1.0),
+            (("is", "is"), 1.0),
+            (("test", "test"), 1.0),
+            (("this", "is"), 1.0),
+            (("this", "this"), 1.0),
+        ],
+    )
+
+
+def test_bigram3():
+    b = BigramCollocationFinder.from_words(SENT, window_size=3)
+    assert sorted(b.ngram_fd.items()) == sorted(
+        [
+            (("a", "test"), 3),
+            (("is", "a"), 3),
+            (("this", "is"), 3),
+            (("a", "a"), 1),
+            (("is", "is"), 1),
+            (("test", "test"), 1),
+            (("this", "this"), 1),
+        ]
+    )
+
+    assert sorted(b.word_fd.items()) == sorted(
+        [("a", 2), ("is", 2), ("test", 2), ("this", 2)]
+    )
+
+    assert (
+        len(SENT) == sum(b.word_fd.values()) == (sum(b.ngram_fd.values()) + 2 + 1) / 2.0
+    )
+    assert close_enough(
+        sorted(b.score_ngrams(BigramAssocMeasures.pmi)),
+        sorted(
+            [
+                (("a", "test"), 1.584962500721156),
+                (("is", "a"), 1.584962500721156),
+                (("this", "is"), 1.584962500721156),
+                (("a", "a"), 0.0),
+                (("is", "is"), 0.0),
+                (("test", "test"), 0.0),
+                (("this", "this"), 0.0),
+            ]
+        ),
+    )
+
+
+def test_bigram5():
+    b = BigramCollocationFinder.from_words(SENT, window_size=5)
+    assert sorted(b.ngram_fd.items()) == sorted(
+        [
+            (("a", "test"), 4),
+            (("is", "a"), 4),
+            (("this", "is"), 4),
+            (("is", "test"), 3),
+            (("this", "a"), 3),
+            (("a", "a"), 1),
+            (("is", "is"), 1),
+            (("test", "test"), 1),
+            (("this", "this"), 1),
+        ]
+    )
+    assert sorted(b.word_fd.items()) == sorted(
+        [("a", 2), ("is", 2), ("test", 2), ("this", 2)]
+    )
+    n_word_fd = sum(b.word_fd.values())
+    n_ngram_fd = (sum(b.ngram_fd.values()) + 4 + 3 + 2 + 1) / 4.0
+    assert len(SENT) == n_word_fd == n_ngram_fd
+    assert close_enough(
+        sorted(b.score_ngrams(BigramAssocMeasures.pmi)),
+        sorted(
+            [
+                (("a", "test"), 1.0),
+                (("is", "a"), 1.0),
+                (("this", "is"), 1.0),
+                (("is", "test"), 0.5849625007211562),
+                (("this", "a"), 0.5849625007211562),
+                (("a", "a"), -1.0),
+                (("is", "is"), -1.0),
+                (("test", "test"), -1.0),
+                (("this", "this"), -1.0),
+            ]
+        ),
+    )

venv/lib/python3.10/site-packages/nltk/test/unit/test_concordance.py

@@ -0,0 +1,98 @@
+import contextlib
+import sys
+import unittest
+from io import StringIO
+
+from nltk.corpus import gutenberg
+from nltk.text import Text
+
+
+@contextlib.contextmanager
+def stdout_redirect(where):
+    sys.stdout = where
+    try:
+        yield where
+    finally:
+        sys.stdout = sys.__stdout__
+
+
+class TestConcordance(unittest.TestCase):
+    """Text constructed using: https://www.nltk.org/book/ch01.html"""
+
+    @classmethod
+    def setUpClass(cls):
+        cls.corpus = gutenberg.words("melville-moby_dick.txt")
+
+    @classmethod
+    def tearDownClass(cls):
+        pass
+
+    def setUp(self):
+        self.text = Text(TestConcordance.corpus)
+        self.query = "monstrous"
+        self.maxDiff = None
+        self.list_out = [
+            "ong the former , one was of a most monstrous size . ... This came towards us , ",
+            'ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have r',
+            "ll over with a heathenish array of monstrous clubs and spears . Some were thick",
+            "d as you gazed , and wondered what monstrous cannibal and savage could ever hav",
+            "that has survived the flood ; most monstrous and most mountainous ! That Himmal",
+            "they might scout at Moby Dick as a monstrous fable , or still worse and more de",
+            "th of Radney .'\" CHAPTER 55 Of the Monstrous Pictures of Whales . I shall ere l",
+            "ing Scenes . In connexion with the monstrous pictures of whales , I am strongly",
+            "ere to enter upon those still more monstrous stories of them which are to be fo",
+            "ght have been rummaged out of this monstrous cabinet there is no telling . But ",
+            "of Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead u",
+        ]
+
+    def tearDown(self):
+        pass
+
+    def test_concordance_list(self):
+        concordance_out = self.text.concordance_list(self.query)
+        self.assertEqual(self.list_out, [c.line for c in concordance_out])
+
+    def test_concordance_width(self):
+        list_out = [
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "Monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+            "monstrous",
+        ]
+
+        concordance_out = self.text.concordance_list(self.query, width=0)
+        self.assertEqual(list_out, [c.query for c in concordance_out])
+
+    def test_concordance_lines(self):
+        concordance_out = self.text.concordance_list(self.query, lines=3)
+        self.assertEqual(self.list_out[:3], [c.line for c in concordance_out])
+
+    def test_concordance_print(self):
+        print_out = """Displaying 11 of 11 matches:
+        ong the former , one was of a most monstrous size . ... This came towards us ,
+        ON OF THE PSALMS . " Touching that monstrous bulk of the whale or ork we have r
+        ll over with a heathenish array of monstrous clubs and spears . Some were thick
+        d as you gazed , and wondered what monstrous cannibal and savage could ever hav
+        that has survived the flood ; most monstrous and most mountainous ! That Himmal
+        they might scout at Moby Dick as a monstrous fable , or still worse and more de
+        th of Radney .'" CHAPTER 55 Of the Monstrous Pictures of Whales . I shall ere l
+        ing Scenes . In connexion with the monstrous pictures of whales , I am strongly
+        ere to enter upon those still more monstrous stories of them which are to be fo
+        ght have been rummaged out of this monstrous cabinet there is no telling . But
+        of Whale - Bones ; for Whales of a monstrous size are oftentimes cast up dead u
+        """
+
+        with stdout_redirect(StringIO()) as stdout:
+            self.text.concordance(self.query)
+
+        def strip_space(raw_str):
+            return raw_str.replace(" ", "")
+
+        self.assertEqual(strip_space(print_out), strip_space(stdout.getvalue()))

venv/lib/python3.10/site-packages/nltk/test/unit/test_corenlp.py

@@ -0,0 +1,1436 @@
+"""
+Mock test for Stanford CoreNLP wrappers.
+"""
+
+from unittest import TestCase
+from unittest.mock import MagicMock
+
+import pytest
+
+from nltk.parse import corenlp
+from nltk.tree import Tree
+
+
+def setup_module(module):
+    global server
+
+    try:
+        server = corenlp.CoreNLPServer(port=9000)
+    except LookupError:
+        pytest.skip("Could not instantiate CoreNLPServer.")
+
+    try:
+        server.start()
+    except corenlp.CoreNLPServerError as e:
+        pytest.skip(
+            "Skipping CoreNLP tests because the server could not be started. "
+            "Make sure that the 9000 port is free. "
+            "{}".format(e.strerror)
+        )
+
+
+def teardown_module(module):
+    server.stop()
+
+
+class TestTokenizerAPI(TestCase):
+    def test_tokenize(self):
+        corenlp_tokenizer = corenlp.CoreNLPParser()
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "index": 0,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 4,
+                            "index": 1,
+                            "originalText": "Good",
+                            "word": "Good",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 5,
+                            "characterOffsetEnd": 12,
+                            "index": 2,
+                            "originalText": "muffins",
+                            "word": "muffins",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 13,
+                            "characterOffsetEnd": 17,
+                            "index": 3,
+                            "originalText": "cost",
+                            "word": "cost",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 18,
+                            "characterOffsetEnd": 19,
+                            "index": 4,
+                            "originalText": "$",
+                            "word": "$",
+                        },
+                        {
+                            "after": "\n",
+                            "before": "",
+                            "characterOffsetBegin": 19,
+                            "characterOffsetEnd": 23,
+                            "index": 5,
+                            "originalText": "3.88",
+                            "word": "3.88",
+                        },
+                        {
+                            "after": " ",
+                            "before": "\n",
+                            "characterOffsetBegin": 24,
+                            "characterOffsetEnd": 26,
+                            "index": 6,
+                            "originalText": "in",
+                            "word": "in",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 27,
+                            "characterOffsetEnd": 30,
+                            "index": 7,
+                            "originalText": "New",
+                            "word": "New",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 31,
+                            "characterOffsetEnd": 35,
+                            "index": 8,
+                            "originalText": "York",
+                            "word": "York",
+                        },
+                        {
+                            "after": "  ",
+                            "before": "",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 36,
+                            "index": 9,
+                            "originalText": ".",
+                            "word": ".",
+                        },
+                    ],
+                },
+                {
+                    "index": 1,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "  ",
+                            "characterOffsetBegin": 38,
+                            "characterOffsetEnd": 44,
+                            "index": 1,
+                            "originalText": "Please",
+                            "word": "Please",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 45,
+                            "characterOffsetEnd": 48,
+                            "index": 2,
+                            "originalText": "buy",
+                            "word": "buy",
+                        },
+                        {
+                            "after": "\n",
+                            "before": " ",
+                            "characterOffsetBegin": 49,
+                            "characterOffsetEnd": 51,
+                            "index": 3,
+                            "originalText": "me",
+                            "word": "me",
+                        },
+                        {
+                            "after": " ",
+                            "before": "\n",
+                            "characterOffsetBegin": 52,
+                            "characterOffsetEnd": 55,
+                            "index": 4,
+                            "originalText": "two",
+                            "word": "two",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 56,
+                            "characterOffsetEnd": 58,
+                            "index": 5,
+                            "originalText": "of",
+                            "word": "of",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 59,
+                            "characterOffsetEnd": 63,
+                            "index": 6,
+                            "originalText": "them",
+                            "word": "them",
+                        },
+                        {
+                            "after": "\n",
+                            "before": "",
+                            "characterOffsetBegin": 63,
+                            "characterOffsetEnd": 64,
+                            "index": 7,
+                            "originalText": ".",
+                            "word": ".",
+                        },
+                    ],
+                },
+                {
+                    "index": 2,
+                    "tokens": [
+                        {
+                            "after": "",
+                            "before": "\n",
+                            "characterOffsetBegin": 65,
+                            "characterOffsetEnd": 71,
+                            "index": 1,
+                            "originalText": "Thanks",
+                            "word": "Thanks",
+                        },
+                        {
+                            "after": "",
+                            "before": "",
+                            "characterOffsetBegin": 71,
+                            "characterOffsetEnd": 72,
+                            "index": 2,
+                            "originalText": ".",
+                            "word": ".",
+                        },
+                    ],
+                },
+            ]
+        }
+        corenlp_tokenizer.api_call = MagicMock(return_value=api_return_value)
+
+        input_string = "Good muffins cost $3.88\nin New York.  Please buy me\ntwo of them.\nThanks."
+
+        expected_output = [
+            "Good",
+            "muffins",
+            "cost",
+            "$",
+            "3.88",
+            "in",
+            "New",
+            "York",
+            ".",
+            "Please",
+            "buy",
+            "me",
+            "two",
+            "of",
+            "them",
+            ".",
+            "Thanks",
+            ".",
+        ]
+
+        tokenized_output = list(corenlp_tokenizer.tokenize(input_string))
+
+        corenlp_tokenizer.api_call.assert_called_once_with(
+            "Good muffins cost $3.88\nin New York.  Please buy me\ntwo of them.\nThanks.",
+            properties={"annotators": "tokenize,ssplit"},
+        )
+        self.assertEqual(expected_output, tokenized_output)
+
+
+class TestTaggerAPI(TestCase):
+    def test_pos_tagger(self):
+        corenlp_tagger = corenlp.CoreNLPParser(tagtype="pos")
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "basicDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 1,
+                            "dependentGloss": "What",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "cop",
+                            "dependent": 2,
+                            "dependentGloss": "is",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 3,
+                            "dependentGloss": "the",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "airspeed",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 5,
+                            "dependentGloss": "of",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 6,
+                            "dependentGloss": "an",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "compound",
+                            "dependent": 7,
+                            "dependentGloss": "unladen",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "nmod",
+                            "dependent": 8,
+                            "dependentGloss": "swallow",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "punct",
+                            "dependent": 9,
+                            "dependentGloss": "?",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                    ],
+                    "enhancedDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 1,
+                            "dependentGloss": "What",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "cop",
+                            "dependent": 2,
+                            "dependentGloss": "is",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 3,
+                            "dependentGloss": "the",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "airspeed",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 5,
+                            "dependentGloss": "of",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 6,
+                            "dependentGloss": "an",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "compound",
+                            "dependent": 7,
+                            "dependentGloss": "unladen",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "nmod:of",
+                            "dependent": 8,
+                            "dependentGloss": "swallow",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "punct",
+                            "dependent": 9,
+                            "dependentGloss": "?",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                    ],
+                    "enhancedPlusPlusDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 1,
+                            "dependentGloss": "What",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "cop",
+                            "dependent": 2,
+                            "dependentGloss": "is",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 3,
+                            "dependentGloss": "the",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "airspeed",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 5,
+                            "dependentGloss": "of",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 6,
+                            "dependentGloss": "an",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "compound",
+                            "dependent": 7,
+                            "dependentGloss": "unladen",
+                            "governor": 8,
+                            "governorGloss": "swallow",
+                        },
+                        {
+                            "dep": "nmod:of",
+                            "dependent": 8,
+                            "dependentGloss": "swallow",
+                            "governor": 4,
+                            "governorGloss": "airspeed",
+                        },
+                        {
+                            "dep": "punct",
+                            "dependent": 9,
+                            "dependentGloss": "?",
+                            "governor": 1,
+                            "governorGloss": "What",
+                        },
+                    ],
+                    "index": 0,
+                    "parse": "(ROOT\n  (SBARQ\n    (WHNP (WP What))\n    (SQ (VBZ is)\n      (NP\n        (NP (DT the) (NN airspeed))\n        (PP (IN of)\n          (NP (DT an) (NN unladen) (NN swallow)))))\n    (. ?)))",
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 4,
+                            "index": 1,
+                            "lemma": "what",
+                            "originalText": "What",
+                            "pos": "WP",
+                            "word": "What",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 5,
+                            "characterOffsetEnd": 7,
+                            "index": 2,
+                            "lemma": "be",
+                            "originalText": "is",
+                            "pos": "VBZ",
+                            "word": "is",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 8,
+                            "characterOffsetEnd": 11,
+                            "index": 3,
+                            "lemma": "the",
+                            "originalText": "the",
+                            "pos": "DT",
+                            "word": "the",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 12,
+                            "characterOffsetEnd": 20,
+                            "index": 4,
+                            "lemma": "airspeed",
+                            "originalText": "airspeed",
+                            "pos": "NN",
+                            "word": "airspeed",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 21,
+                            "characterOffsetEnd": 23,
+                            "index": 5,
+                            "lemma": "of",
+                            "originalText": "of",
+                            "pos": "IN",
+                            "word": "of",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 24,
+                            "characterOffsetEnd": 26,
+                            "index": 6,
+                            "lemma": "a",
+                            "originalText": "an",
+                            "pos": "DT",
+                            "word": "an",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 27,
+                            "characterOffsetEnd": 34,
+                            "index": 7,
+                            "lemma": "unladen",
+                            "originalText": "unladen",
+                            "pos": "JJ",
+                            "word": "unladen",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 42,
+                            "index": 8,
+                            "lemma": "swallow",
+                            "originalText": "swallow",
+                            "pos": "VB",
+                            "word": "swallow",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 43,
+                            "characterOffsetEnd": 44,
+                            "index": 9,
+                            "lemma": "?",
+                            "originalText": "?",
+                            "pos": ".",
+                            "word": "?",
+                        },
+                    ],
+                }
+            ]
+        }
+        corenlp_tagger.api_call = MagicMock(return_value=api_return_value)
+
+        input_tokens = "What is the airspeed of an unladen swallow ?".split()
+        expected_output = [
+            ("What", "WP"),
+            ("is", "VBZ"),
+            ("the", "DT"),
+            ("airspeed", "NN"),
+            ("of", "IN"),
+            ("an", "DT"),
+            ("unladen", "JJ"),
+            ("swallow", "VB"),
+            ("?", "."),
+        ]
+        tagged_output = corenlp_tagger.tag(input_tokens)
+
+        corenlp_tagger.api_call.assert_called_once_with(
+            "What is the airspeed of an unladen swallow ?",
+            properties={
+                "ssplit.isOneSentence": "true",
+                "annotators": "tokenize,ssplit,pos",
+            },
+        )
+        self.assertEqual(expected_output, tagged_output)
+
+    def test_ner_tagger(self):
+        corenlp_tagger = corenlp.CoreNLPParser(tagtype="ner")
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "index": 0,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 4,
+                            "index": 1,
+                            "lemma": "Rami",
+                            "ner": "PERSON",
+                            "originalText": "Rami",
+                            "pos": "NNP",
+                            "word": "Rami",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 5,
+                            "characterOffsetEnd": 8,
+                            "index": 2,
+                            "lemma": "Eid",
+                            "ner": "PERSON",
+                            "originalText": "Eid",
+                            "pos": "NNP",
+                            "word": "Eid",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 9,
+                            "characterOffsetEnd": 11,
+                            "index": 3,
+                            "lemma": "be",
+                            "ner": "O",
+                            "originalText": "is",
+                            "pos": "VBZ",
+                            "word": "is",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 12,
+                            "characterOffsetEnd": 20,
+                            "index": 4,
+                            "lemma": "study",
+                            "ner": "O",
+                            "originalText": "studying",
+                            "pos": "VBG",
+                            "word": "studying",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 21,
+                            "characterOffsetEnd": 23,
+                            "index": 5,
+                            "lemma": "at",
+                            "ner": "O",
+                            "originalText": "at",
+                            "pos": "IN",
+                            "word": "at",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 24,
+                            "characterOffsetEnd": 29,
+                            "index": 6,
+                            "lemma": "Stony",
+                            "ner": "ORGANIZATION",
+                            "originalText": "Stony",
+                            "pos": "NNP",
+                            "word": "Stony",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 30,
+                            "characterOffsetEnd": 35,
+                            "index": 7,
+                            "lemma": "Brook",
+                            "ner": "ORGANIZATION",
+                            "originalText": "Brook",
+                            "pos": "NNP",
+                            "word": "Brook",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 36,
+                            "characterOffsetEnd": 46,
+                            "index": 8,
+                            "lemma": "University",
+                            "ner": "ORGANIZATION",
+                            "originalText": "University",
+                            "pos": "NNP",
+                            "word": "University",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 47,
+                            "characterOffsetEnd": 49,
+                            "index": 9,
+                            "lemma": "in",
+                            "ner": "O",
+                            "originalText": "in",
+                            "pos": "IN",
+                            "word": "in",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 50,
+                            "characterOffsetEnd": 52,
+                            "index": 10,
+                            "lemma": "NY",
+                            "ner": "O",
+                            "originalText": "NY",
+                            "pos": "NNP",
+                            "word": "NY",
+                        },
+                    ],
+                }
+            ]
+        }
+
+        corenlp_tagger.api_call = MagicMock(return_value=api_return_value)
+
+        input_tokens = "Rami Eid is studying at Stony Brook University in NY".split()
+        expected_output = [
+            ("Rami", "PERSON"),
+            ("Eid", "PERSON"),
+            ("is", "O"),
+            ("studying", "O"),
+            ("at", "O"),
+            ("Stony", "ORGANIZATION"),
+            ("Brook", "ORGANIZATION"),
+            ("University", "ORGANIZATION"),
+            ("in", "O"),
+            ("NY", "O"),
+        ]
+        tagged_output = corenlp_tagger.tag(input_tokens)
+
+        corenlp_tagger.api_call.assert_called_once_with(
+            "Rami Eid is studying at Stony Brook University in NY",
+            properties={
+                "ssplit.isOneSentence": "true",
+                "annotators": "tokenize,ssplit,ner",
+            },
+        )
+        self.assertEqual(expected_output, tagged_output)
+
+    def test_unexpected_tagtype(self):
+        with self.assertRaises(ValueError):
+            corenlp_tagger = corenlp.CoreNLPParser(tagtype="test")
+
+
+class TestParserAPI(TestCase):
+    def test_parse(self):
+        corenlp_parser = corenlp.CoreNLPParser()
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "basicDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "dep",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "dep",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedPlusPlusDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "dep",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "index": 0,
+                    "parse": "(ROOT\n  (NP\n    (NP (DT The) (JJ quick) (JJ brown) (NN fox))\n    (NP\n      (NP (NNS jumps))\n      (PP (IN over)\n        (NP (DT the) (JJ lazy) (NN dog))))))",
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 3,
+                            "index": 1,
+                            "lemma": "the",
+                            "originalText": "The",
+                            "pos": "DT",
+                            "word": "The",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 4,
+                            "characterOffsetEnd": 9,
+                            "index": 2,
+                            "lemma": "quick",
+                            "originalText": "quick",
+                            "pos": "JJ",
+                            "word": "quick",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 10,
+                            "characterOffsetEnd": 15,
+                            "index": 3,
+                            "lemma": "brown",
+                            "originalText": "brown",
+                            "pos": "JJ",
+                            "word": "brown",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 16,
+                            "characterOffsetEnd": 19,
+                            "index": 4,
+                            "lemma": "fox",
+                            "originalText": "fox",
+                            "pos": "NN",
+                            "word": "fox",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 20,
+                            "characterOffsetEnd": 25,
+                            "index": 5,
+                            "lemma": "jump",
+                            "originalText": "jumps",
+                            "pos": "VBZ",
+                            "word": "jumps",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 26,
+                            "characterOffsetEnd": 30,
+                            "index": 6,
+                            "lemma": "over",
+                            "originalText": "over",
+                            "pos": "IN",
+                            "word": "over",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 31,
+                            "characterOffsetEnd": 34,
+                            "index": 7,
+                            "lemma": "the",
+                            "originalText": "the",
+                            "pos": "DT",
+                            "word": "the",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 39,
+                            "index": 8,
+                            "lemma": "lazy",
+                            "originalText": "lazy",
+                            "pos": "JJ",
+                            "word": "lazy",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 40,
+                            "characterOffsetEnd": 43,
+                            "index": 9,
+                            "lemma": "dog",
+                            "originalText": "dog",
+                            "pos": "NN",
+                            "word": "dog",
+                        },
+                    ],
+                }
+            ]
+        }
+
+        corenlp_parser.api_call = MagicMock(return_value=api_return_value)
+
+        input_string = "The quick brown fox jumps over the lazy dog".split()
+        expected_output = Tree(
+            "ROOT",
+            [
+                Tree(
+                    "NP",
+                    [
+                        Tree(
+                            "NP",
+                            [
+                                Tree("DT", ["The"]),
+                                Tree("JJ", ["quick"]),
+                                Tree("JJ", ["brown"]),
+                                Tree("NN", ["fox"]),
+                            ],
+                        ),
+                        Tree(
+                            "NP",
+                            [
+                                Tree("NP", [Tree("NNS", ["jumps"])]),
+                                Tree(
+                                    "PP",
+                                    [
+                                        Tree("IN", ["over"]),
+                                        Tree(
+                                            "NP",
+                                            [
+                                                Tree("DT", ["the"]),
+                                                Tree("JJ", ["lazy"]),
+                                                Tree("NN", ["dog"]),
+                                            ],
+                                        ),
+                                    ],
+                                ),
+                            ],
+                        ),
+                    ],
+                )
+            ],
+        )
+
+        parsed_data = next(corenlp_parser.parse(input_string))
+
+        corenlp_parser.api_call.assert_called_once_with(
+            "The quick brown fox jumps over the lazy dog",
+            properties={"ssplit.eolonly": "true"},
+        )
+        self.assertEqual(expected_output, parsed_data)
+
+    def test_dependency_parser(self):
+        corenlp_parser = corenlp.CoreNLPDependencyParser()
+
+        api_return_value = {
+            "sentences": [
+                {
+                    "basicDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "enhancedPlusPlusDependencies": [
+                        {
+                            "dep": "ROOT",
+                            "dependent": 5,
+                            "dependentGloss": "jumps",
+                            "governor": 0,
+                            "governorGloss": "ROOT",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 1,
+                            "dependentGloss": "The",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 2,
+                            "dependentGloss": "quick",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 3,
+                            "dependentGloss": "brown",
+                            "governor": 4,
+                            "governorGloss": "fox",
+                        },
+                        {
+                            "dep": "nsubj",
+                            "dependent": 4,
+                            "dependentGloss": "fox",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                        {
+                            "dep": "case",
+                            "dependent": 6,
+                            "dependentGloss": "over",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "det",
+                            "dependent": 7,
+                            "dependentGloss": "the",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "amod",
+                            "dependent": 8,
+                            "dependentGloss": "lazy",
+                            "governor": 9,
+                            "governorGloss": "dog",
+                        },
+                        {
+                            "dep": "nmod:over",
+                            "dependent": 9,
+                            "dependentGloss": "dog",
+                            "governor": 5,
+                            "governorGloss": "jumps",
+                        },
+                    ],
+                    "index": 0,
+                    "tokens": [
+                        {
+                            "after": " ",
+                            "before": "",
+                            "characterOffsetBegin": 0,
+                            "characterOffsetEnd": 3,
+                            "index": 1,
+                            "lemma": "the",
+                            "originalText": "The",
+                            "pos": "DT",
+                            "word": "The",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 4,
+                            "characterOffsetEnd": 9,
+                            "index": 2,
+                            "lemma": "quick",
+                            "originalText": "quick",
+                            "pos": "JJ",
+                            "word": "quick",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 10,
+                            "characterOffsetEnd": 15,
+                            "index": 3,
+                            "lemma": "brown",
+                            "originalText": "brown",
+                            "pos": "JJ",
+                            "word": "brown",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 16,
+                            "characterOffsetEnd": 19,
+                            "index": 4,
+                            "lemma": "fox",
+                            "originalText": "fox",
+                            "pos": "NN",
+                            "word": "fox",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 20,
+                            "characterOffsetEnd": 25,
+                            "index": 5,
+                            "lemma": "jump",
+                            "originalText": "jumps",
+                            "pos": "VBZ",
+                            "word": "jumps",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 26,
+                            "characterOffsetEnd": 30,
+                            "index": 6,
+                            "lemma": "over",
+                            "originalText": "over",
+                            "pos": "IN",
+                            "word": "over",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 31,
+                            "characterOffsetEnd": 34,
+                            "index": 7,
+                            "lemma": "the",
+                            "originalText": "the",
+                            "pos": "DT",
+                            "word": "the",
+                        },
+                        {
+                            "after": " ",
+                            "before": " ",
+                            "characterOffsetBegin": 35,
+                            "characterOffsetEnd": 39,
+                            "index": 8,
+                            "lemma": "lazy",
+                            "originalText": "lazy",
+                            "pos": "JJ",
+                            "word": "lazy",
+                        },
+                        {
+                            "after": "",
+                            "before": " ",
+                            "characterOffsetBegin": 40,
+                            "characterOffsetEnd": 43,
+                            "index": 9,
+                            "lemma": "dog",
+                            "originalText": "dog",
+                            "pos": "NN",
+                            "word": "dog",
+                        },
+                    ],
+                }
+            ]
+        }
+
+        corenlp_parser.api_call = MagicMock(return_value=api_return_value)
+
+        input_string = "The quick brown fox jumps over the lazy dog".split()
+        expected_output = Tree(
+            "jumps",
+            [
+                Tree("fox", ["The", "quick", "brown"]),
+                Tree("dog", ["over", "the", "lazy"]),
+            ],
+        )
+
+        parsed_data = next(corenlp_parser.parse(input_string))
+
+        corenlp_parser.api_call.assert_called_once_with(
+            "The quick brown fox jumps over the lazy dog",
+            properties={"ssplit.eolonly": "true"},
+        )
+        self.assertEqual(expected_output, parsed_data.tree())

venv/lib/python3.10/site-packages/nltk/test/unit/test_corpora.py

@@ -0,0 +1,274 @@
+import unittest
+
+import pytest
+
+from nltk.corpus import (  # mwa_ppdb
+    cess_cat,
+    cess_esp,
+    conll2007,
+    floresta,
+    indian,
+    ptb,
+    sinica_treebank,
+    udhr,
+)
+from nltk.tree import Tree
+
+
+class TestUdhr(unittest.TestCase):
+    def test_words(self):
+        for name in udhr.fileids():
+            words = list(udhr.words(name))
+            self.assertTrue(words)
+
+    def test_raw_unicode(self):
+        for name in udhr.fileids():
+            txt = udhr.raw(name)
+            assert not isinstance(txt, bytes), name
+
+    def test_polish_encoding(self):
+        text_pl = udhr.raw("Polish-Latin2")[:164]
+        text_ppl = udhr.raw("Polish_Polski-Latin2")[:164]
+        expected = """POWSZECHNA DEKLARACJA PRAW CZŁOWIEKA
+[Preamble]
+Trzecia Sesja Ogólnego Zgromadzenia ONZ, obradująca w Paryżu, \
+uchwaliła 10 grudnia 1948 roku jednomyślnie Powszechną"""
+        assert text_pl == expected, "Polish-Latin2"
+        assert text_ppl == expected, "Polish_Polski-Latin2"
+
+
+class TestIndian(unittest.TestCase):
+    def test_words(self):
+        words = indian.words()[:3]
+        self.assertEqual(words, ["মহিষের", "সন্তান", ":"])
+
+    def test_tagged_words(self):
+        tagged_words = indian.tagged_words()[:3]
+        self.assertEqual(
+            tagged_words, [("মহিষের", "NN"), ("সন্তান", "NN"), (":", "SYM")]
+        )
+
+
+class TestCess(unittest.TestCase):
+    def test_catalan(self):
+        words = cess_cat.words()[:15]
+        txt = "El Tribunal_Suprem -Fpa- TS -Fpt- ha confirmat la condemna a quatre anys d' inhabilitació especial"
+        self.assertEqual(words, txt.split())
+        self.assertEqual(cess_cat.tagged_sents()[0][34][0], "càrrecs")
+
+    def test_esp(self):
+        words = cess_esp.words()[:15]
+        txt = "El grupo estatal Electricité_de_France -Fpa- EDF -Fpt- anunció hoy , jueves , la compra del"
+        self.assertEqual(words, txt.split())
+        self.assertEqual(cess_esp.words()[115], "años")
+
+
+class TestFloresta(unittest.TestCase):
+    def test_words(self):
+        words = floresta.words()[:10]
+        txt = "Um revivalismo refrescante O 7_e_Meio é um ex-libris de a"
+        self.assertEqual(words, txt.split())
+
+
+class TestSinicaTreebank(unittest.TestCase):
+    def test_sents(self):
+        first_3_sents = sinica_treebank.sents()[:3]
+        self.assertEqual(
+            first_3_sents, [["一"], ["友情"], ["嘉珍", "和", "我", "住在", "同一條", "巷子"]]
+        )
+
+    def test_parsed_sents(self):
+        parsed_sents = sinica_treebank.parsed_sents()[25]
+        self.assertEqual(
+            parsed_sents,
+            Tree(
+                "S",
+                [
+                    Tree("NP", [Tree("Nba", ["嘉珍"])]),
+                    Tree("V‧地", [Tree("VA11", ["不停"]), Tree("DE", ["的"])]),
+                    Tree("VA4", ["哭泣"]),
+                ],
+            ),
+        )
+
+
+class TestCoNLL2007(unittest.TestCase):
+    # Reading the CoNLL 2007 Dependency Treebanks
+
+    def test_sents(self):
+        sents = conll2007.sents("esp.train")[0]
+        self.assertEqual(
+            sents[:6], ["El", "aumento", "del", "índice", "de", "desempleo"]
+        )
+
+    def test_parsed_sents(self):
+
+        parsed_sents = conll2007.parsed_sents("esp.train")[0]
+
+        self.assertEqual(
+            parsed_sents.tree(),
+            Tree(
+                "fortaleció",
+                [
+                    Tree(
+                        "aumento",
+                        [
+                            "El",
+                            Tree(
+                                "del",
+                                [
+                                    Tree(
+                                        "índice",
+                                        [
+                                            Tree(
+                                                "de",
+                                                [Tree("desempleo", ["estadounidense"])],
+                                            )
+                                        ],
+                                    )
+                                ],
+                            ),
+                        ],
+                    ),
+                    "hoy",
+                    "considerablemente",
+                    Tree(
+                        "al",
+                        [
+                            Tree(
+                                "euro",
+                                [
+                                    Tree(
+                                        "cotizaba",
+                                        [
+                                            ",",
+                                            "que",
+                                            Tree("a", [Tree("15.35", ["las", "GMT"])]),
+                                            "se",
+                                            Tree(
+                                                "en",
+                                                [
+                                                    Tree(
+                                                        "mercado",
+                                                        [
+                                                            "el",
+                                                            Tree("de", ["divisas"]),
+                                                            Tree("de", ["Fráncfort"]),
+                                                        ],
+                                                    )
+                                                ],
+                                            ),
+                                            Tree("a", ["0,9452_dólares"]),
+                                            Tree(
+                                                "frente_a",
+                                                [
+                                                    ",",
+                                                    Tree(
+                                                        "0,9349_dólares",
+                                                        [
+                                                            "los",
+                                                            Tree(
+                                                                "de",
+                                                                [
+                                                                    Tree(
+                                                                        "mañana",
+                                                                        ["esta"],
+                                                                    )
+                                                                ],
+                                                            ),
+                                                        ],
+                                                    ),
+                                                ],
+                                            ),
+                                        ],
+                                    )
+                                ],
+                            )
+                        ],
+                    ),
+                    ".",
+                ],
+            ),
+        )
+
+
+@pytest.mark.skipif(
+    not ptb.fileids(),
+    reason="A full installation of the Penn Treebank is not available",
+)
+class TestPTB(unittest.TestCase):
+    def test_fileids(self):
+        self.assertEqual(
+            ptb.fileids()[:4],
+            [
+                "BROWN/CF/CF01.MRG",
+                "BROWN/CF/CF02.MRG",
+                "BROWN/CF/CF03.MRG",
+                "BROWN/CF/CF04.MRG",
+            ],
+        )
+
+    def test_words(self):
+        self.assertEqual(
+            ptb.words("WSJ/00/WSJ_0003.MRG")[:7],
+            ["A", "form", "of", "asbestos", "once", "used", "*"],
+        )
+
+    def test_tagged_words(self):
+        self.assertEqual(
+            ptb.tagged_words("WSJ/00/WSJ_0003.MRG")[:3],
+            [("A", "DT"), ("form", "NN"), ("of", "IN")],
+        )
+
+    def test_categories(self):
+        self.assertEqual(
+            ptb.categories(),
+            [
+                "adventure",
+                "belles_lettres",
+                "fiction",
+                "humor",
+                "lore",
+                "mystery",
+                "news",
+                "romance",
+                "science_fiction",
+            ],
+        )
+
+    def test_news_fileids(self):
+        self.assertEqual(
+            ptb.fileids("news")[:3],
+            ["WSJ/00/WSJ_0001.MRG", "WSJ/00/WSJ_0002.MRG", "WSJ/00/WSJ_0003.MRG"],
+        )
+
+    def test_category_words(self):
+        self.assertEqual(
+            ptb.words(categories=["humor", "fiction"])[:6],
+            ["Thirty-three", "Scotty", "did", "not", "go", "back"],
+        )
+
+
+@pytest.mark.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"),
+            ],
+        )

venv/lib/python3.10/site-packages/nltk/test/unit/test_corpus_views.py

@@ -0,0 +1,48 @@
+"""
+Corpus View Regression Tests
+"""
+import unittest
+
+import nltk.data
+from nltk.corpus.reader.util import (
+    StreamBackedCorpusView,
+    read_line_block,
+    read_whitespace_block,
+)
+
+
+class TestCorpusViews(unittest.TestCase):
+
+    linetok = nltk.LineTokenizer(blanklines="keep")
+    names = [
+        "corpora/inaugural/README",  # A very short file (160 chars)
+        "corpora/inaugural/1793-Washington.txt",  # A relatively short file (791 chars)
+        "corpora/inaugural/1909-Taft.txt",  # A longer file (32k chars)
+    ]
+
+    def data(self):
+        for name in self.names:
+            f = nltk.data.find(name)
+            with f.open() as fp:
+                file_data = fp.read().decode("utf8")
+            yield f, file_data
+
+    def test_correct_values(self):
+        # Check that corpus views produce the correct sequence of values.
+
+        for f, file_data in self.data():
+            v = StreamBackedCorpusView(f, read_whitespace_block)
+            self.assertEqual(list(v), file_data.split())
+
+            v = StreamBackedCorpusView(f, read_line_block)
+            self.assertEqual(list(v), self.linetok.tokenize(file_data))
+
+    def test_correct_length(self):
+        # Check that the corpus views report the correct lengths:
+
+        for f, file_data in self.data():
+            v = StreamBackedCorpusView(f, read_whitespace_block)
+            self.assertEqual(len(v), len(file_data.split()))
+
+            v = StreamBackedCorpusView(f, read_line_block)
+            self.assertEqual(len(v), len(self.linetok.tokenize(file_data)))

venv/lib/python3.10/site-packages/nltk/test/unit/test_data.py

@@ -0,0 +1,15 @@
+import pytest
+
+import nltk.data
+
+
+def test_find_raises_exception():
+    with pytest.raises(LookupError):
+        nltk.data.find("no_such_resource/foo")
+
+
+def test_find_raises_exception_with_full_resource_name():
+    no_such_thing = "no_such_thing/bar"
+    with pytest.raises(LookupError) as exc:
+        nltk.data.find(no_such_thing)
+        assert no_such_thing in str(exc)

venv/lib/python3.10/site-packages/nltk/test/unit/test_disagreement.py

@@ -0,0 +1,144 @@
+import unittest
+
+from nltk.metrics.agreement import AnnotationTask
+
+
+class TestDisagreement(unittest.TestCase):
+
+    """
+    Class containing unit tests for nltk.metrics.agreement.Disagreement.
+    """
+
+    def test_easy(self):
+        """
+        Simple test, based on
+        https://github.com/foolswood/krippendorffs_alpha/raw/master/krippendorff.pdf.
+        """
+        data = [
+            ("coder1", "dress1", "YES"),
+            ("coder2", "dress1", "NO"),
+            ("coder3", "dress1", "NO"),
+            ("coder1", "dress2", "YES"),
+            ("coder2", "dress2", "NO"),
+            ("coder3", "dress3", "NO"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), -0.3333333)
+
+    def test_easy2(self):
+        """
+        Same simple test with 1 rating removed.
+        Removal of that rating should not matter: K-Apha ignores items with
+        only 1 rating.
+        """
+        data = [
+            ("coder1", "dress1", "YES"),
+            ("coder2", "dress1", "NO"),
+            ("coder3", "dress1", "NO"),
+            ("coder1", "dress2", "YES"),
+            ("coder2", "dress2", "NO"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), -0.3333333)
+
+    def test_advanced(self):
+        """
+        More advanced test, based on
+        http://www.agreestat.com/research_papers/onkrippendorffalpha.pdf
+        """
+        data = [
+            ("A", "1", "1"),
+            ("B", "1", "1"),
+            ("D", "1", "1"),
+            ("A", "2", "2"),
+            ("B", "2", "2"),
+            ("C", "2", "3"),
+            ("D", "2", "2"),
+            ("A", "3", "3"),
+            ("B", "3", "3"),
+            ("C", "3", "3"),
+            ("D", "3", "3"),
+            ("A", "4", "3"),
+            ("B", "4", "3"),
+            ("C", "4", "3"),
+            ("D", "4", "3"),
+            ("A", "5", "2"),
+            ("B", "5", "2"),
+            ("C", "5", "2"),
+            ("D", "5", "2"),
+            ("A", "6", "1"),
+            ("B", "6", "2"),
+            ("C", "6", "3"),
+            ("D", "6", "4"),
+            ("A", "7", "4"),
+            ("B", "7", "4"),
+            ("C", "7", "4"),
+            ("D", "7", "4"),
+            ("A", "8", "1"),
+            ("B", "8", "1"),
+            ("C", "8", "2"),
+            ("D", "8", "1"),
+            ("A", "9", "2"),
+            ("B", "9", "2"),
+            ("C", "9", "2"),
+            ("D", "9", "2"),
+            ("B", "10", "5"),
+            ("C", "10", "5"),
+            ("D", "10", "5"),
+            ("C", "11", "1"),
+            ("D", "11", "1"),
+            ("C", "12", "3"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), 0.743421052632)
+
+    def test_advanced2(self):
+        """
+        Same more advanced example, but with 1 rating removed.
+        Again, removal of that 1 rating should not matter.
+        """
+        data = [
+            ("A", "1", "1"),
+            ("B", "1", "1"),
+            ("D", "1", "1"),
+            ("A", "2", "2"),
+            ("B", "2", "2"),
+            ("C", "2", "3"),
+            ("D", "2", "2"),
+            ("A", "3", "3"),
+            ("B", "3", "3"),
+            ("C", "3", "3"),
+            ("D", "3", "3"),
+            ("A", "4", "3"),
+            ("B", "4", "3"),
+            ("C", "4", "3"),
+            ("D", "4", "3"),
+            ("A", "5", "2"),
+            ("B", "5", "2"),
+            ("C", "5", "2"),
+            ("D", "5", "2"),
+            ("A", "6", "1"),
+            ("B", "6", "2"),
+            ("C", "6", "3"),
+            ("D", "6", "4"),
+            ("A", "7", "4"),
+            ("B", "7", "4"),
+            ("C", "7", "4"),
+            ("D", "7", "4"),
+            ("A", "8", "1"),
+            ("B", "8", "1"),
+            ("C", "8", "2"),
+            ("D", "8", "1"),
+            ("A", "9", "2"),
+            ("B", "9", "2"),
+            ("C", "9", "2"),
+            ("D", "9", "2"),
+            ("B", "10", "5"),
+            ("C", "10", "5"),
+            ("D", "10", "5"),
+            ("C", "11", "1"),
+            ("D", "11", "1"),
+            ("C", "12", "3"),
+        ]
+        annotation_task = AnnotationTask(data)
+        self.assertAlmostEqual(annotation_task.alpha(), 0.743421052632)

venv/lib/python3.10/site-packages/nltk/test/unit/test_distance.py

@@ -0,0 +1,129 @@
+from typing import Tuple
+
+import pytest
+
+from nltk.metrics.distance import edit_distance
+
+
+class TestEditDistance:
+    @pytest.mark.parametrize(
+        "left,right,substitution_cost,expecteds",
+        [
+            # Allowing transpositions reduces the number of edits required.
+            # with transpositions:
+            # e.g. "abc" -T-> "cba" -D-> "ca": 2 steps
+            #
+            # without transpositions:
+            # e.g. "abc" -D-> "ab" -D-> "a" -I-> "ca": 3 steps
+            ("abc", "ca", 1, (2, 3)),
+            ("abc", "ca", 5, (2, 3)),  # Doesn't *require* substitutions
+            # Note, a substition_cost of higher than 2 doesn't make much
+            # sense, as a deletion + insertion is identical, and always
+            # costs 2.
+            #
+            #
+            # Transpositions don't always reduce the number of edits required:
+            # with or without transpositions:
+            # e.g. "wants" -D-> "wats" -D-> "was" -I-> "wasp": 3 steps
+            ("wants", "wasp", 1, (3, 3)),
+            ("wants", "wasp", 5, (3, 3)),  # Doesn't *require* substitutions
+            #
+            #
+            # Ought to have the same results with and without transpositions
+            # with or without transpositions:
+            # e.g. "rain" -S-> "sain" -S-> "shin" -I-> "shine": 3 steps
+            # (but cost 5 if substitution_cost=2)
+            ("rain", "shine", 1, (3, 3)),
+            ("rain", "shine", 2, (5, 5)),  # Does *require* substitutions
+            #
+            #
+            # Several potentially interesting typos
+            # with transpositions:
+            # e.g. "acbdef" -T-> "abcdef": 1 step
+            #
+            # without transpositions:
+            # e.g. "acbdef" -D-> "abdef" -I-> "abcdef": 2 steps
+            ("acbdef", "abcdef", 1, (1, 2)),
+            ("acbdef", "abcdef", 2, (1, 2)),  # Doesn't *require* substitutions
+            #
+            #
+            # with transpositions:
+            # e.g. "lnaguaeg" -T-> "languaeg" -T-> "language": 2 steps
+            #
+            # without transpositions:
+            # e.g. "lnaguaeg" -D-> "laguaeg" -I-> "languaeg" -D-> "languag" -I-> "language": 4 steps
+            ("lnaguaeg", "language", 1, (2, 4)),
+            ("lnaguaeg", "language", 2, (2, 4)),  # Doesn't *require* substitutions
+            #
+            #
+            # with transpositions:
+            # e.g. "lnaugage" -T-> "lanugage" -T-> "language": 2 steps
+            #
+            # without transpositions:
+            # e.g. "lnaugage" -S-> "lnangage" -D-> "langage" -I-> "language": 3 steps
+            # (but one substitution, so a cost of 4 if substition_cost = 2)
+            ("lnaugage", "language", 1, (2, 3)),
+            ("lnaugage", "language", 2, (2, 4)),
+            # Does *require* substitutions if no transpositions
+            #
+            #
+            # with transpositions:
+            # e.g. "lngauage" -T-> "lnaguage" -T-> "language": 2 steps
+            # without transpositions:
+            # e.g. "lngauage" -I-> "lanaguage" -D-> "language": 2 steps
+            ("lngauage", "language", 1, (2, 2)),
+            ("lngauage", "language", 2, (2, 2)),  # Doesn't *require* substitutions
+            #
+            #
+            # with or without transpositions:
+            # e.g. "wants" -S-> "sants" -S-> "swnts" -S-> "swits" -S-> "swims" -D-> "swim": 5 steps
+            #
+            # with substitution_cost=2 and transpositions:
+            # e.g. "wants" -T-> "santw" -D-> "sntw" -D-> "stw" -D-> "sw"
+            # -I-> "swi" -I-> "swim": 6 steps
+            #
+            # with substitution_cost=2 and no transpositions:
+            # e.g. "wants" -I-> "swants" -D-> "swant" -D-> "swan" -D-> "swa" -D-> "sw"
+            # -I-> "swi" -I-> "swim": 7 steps
+            ("wants", "swim", 1, (5, 5)),
+            ("wants", "swim", 2, (6, 7)),
+            #
+            #
+            # with or without transpositions:
+            # e.g. "kitten" -S-> "sitten" -s-> "sittin" -I-> "sitting": 3 steps
+            # (but cost 5 if substitution_cost=2)
+            ("kitten", "sitting", 1, (3, 3)),
+            ("kitten", "sitting", 2, (5, 5)),
+            #
+            # duplicated letter
+            # e.g. "duplicated" -D-> "duplicated"
+            ("duplicated", "duuplicated", 1, (1, 1)),
+            ("duplicated", "duuplicated", 2, (1, 1)),
+            ("very duplicated", "very duuplicateed", 2, (2, 2)),
+        ],
+    )
+    def test_with_transpositions(
+        self, left: str, right: str, substitution_cost: int, expecteds: Tuple[int, int]
+    ):
+        """
+        Test `edit_distance` between two strings, given some `substitution_cost`,
+        and whether transpositions are allowed.
+
+        :param str left: First input string to `edit_distance`.
+        :param str right: Second input string to `edit_distance`.
+        :param int substitution_cost: The cost of a substitution action in `edit_distance`.
+        :param Tuple[int, int] expecteds: A tuple of expected outputs, such that `expecteds[0]` is
+            the expected output with `transpositions=True`, and `expecteds[1]` is
+            the expected output with `transpositions=False`.
+        """
+        # Test the input strings in both orderings
+        for s1, s2 in ((left, right), (right, left)):
+            # zip with [True, False] to get the transpositions value
+            for expected, transpositions in zip(expecteds, [True, False]):
+                predicted = edit_distance(
+                    s1,
+                    s2,
+                    substitution_cost=substitution_cost,
+                    transpositions=transpositions,
+                )
+                assert predicted == expected

venv/lib/python3.10/site-packages/nltk/test/unit/test_downloader.py

@@ -0,0 +1,19 @@
+from nltk import download
+
+
+def test_downloader_using_existing_parent_download_dir(tmp_path):
+    """Test that download works properly when the parent folder of the download_dir exists"""
+
+    download_dir = str(tmp_path.joinpath("another_dir"))
+    download_status = download("mwa_ppdb", download_dir)
+    assert download_status is True
+
+
+def test_downloader_using_non_existing_parent_download_dir(tmp_path):
+    """Test that download works properly when the parent folder of the download_dir does not exist"""
+
+    download_dir = str(
+        tmp_path.joinpath("non-existing-parent-folder", "another-non-existing-folder")
+    )
+    download_status = download("mwa_ppdb", download_dir)
+    assert download_status is True

venv/lib/python3.10/site-packages/nltk/test/unit/test_freqdist.py

@@ -0,0 +1,7 @@
+import nltk
+
+
+def test_iterating_returns_an_iterator_ordered_by_frequency():
+    samples = ["one", "two", "two"]
+    distribution = nltk.FreqDist(samples)
+    assert list(distribution) == ["two", "one"]

venv/lib/python3.10/site-packages/nltk/test/unit/test_hmm.py

@@ -0,0 +1,82 @@
+import pytest
+
+from nltk.tag import hmm
+
+
+def _wikipedia_example_hmm():
+    # Example from wikipedia
+    # (https://en.wikipedia.org/wiki/Forward%E2%80%93backward_algorithm)
+
+    states = ["rain", "no rain"]
+    symbols = ["umbrella", "no umbrella"]
+
+    A = [[0.7, 0.3], [0.3, 0.7]]  # transition probabilities
+    B = [[0.9, 0.1], [0.2, 0.8]]  # emission probabilities
+    pi = [0.5, 0.5]  # initial probabilities
+
+    seq = ["umbrella", "umbrella", "no umbrella", "umbrella", "umbrella"]
+    seq = list(zip(seq, [None] * len(seq)))
+
+    model = hmm._create_hmm_tagger(states, symbols, A, B, pi)
+    return model, states, symbols, seq
+
+
+def test_forward_probability():
+    from numpy.testing import assert_array_almost_equal
+
+    # example from p. 385, Huang et al
+    model, states, symbols = hmm._market_hmm_example()
+    seq = [("up", None), ("up", None)]
+    expected = [[0.35, 0.02, 0.09], [0.1792, 0.0085, 0.0357]]
+
+    fp = 2 ** model._forward_probability(seq)
+
+    assert_array_almost_equal(fp, expected)
+
+
+def test_forward_probability2():
+    from numpy.testing import assert_array_almost_equal
+
+    model, states, symbols, seq = _wikipedia_example_hmm()
+    fp = 2 ** model._forward_probability(seq)
+
+    # examples in wikipedia are normalized
+    fp = (fp.T / fp.sum(axis=1)).T
+
+    wikipedia_results = [
+        [0.8182, 0.1818],
+        [0.8834, 0.1166],
+        [0.1907, 0.8093],
+        [0.7308, 0.2692],
+        [0.8673, 0.1327],
+    ]
+
+    assert_array_almost_equal(wikipedia_results, fp, 4)
+
+
+def test_backward_probability():
+    from numpy.testing import assert_array_almost_equal
+
+    model, states, symbols, seq = _wikipedia_example_hmm()
+
+    bp = 2 ** model._backward_probability(seq)
+    # examples in wikipedia are normalized
+
+    bp = (bp.T / bp.sum(axis=1)).T
+
+    wikipedia_results = [
+        # Forward-backward algorithm doesn't need b0_5,
+        # so .backward_probability doesn't compute it.
+        # [0.6469, 0.3531],
+        [0.5923, 0.4077],
+        [0.3763, 0.6237],
+        [0.6533, 0.3467],
+        [0.6273, 0.3727],
+        [0.5, 0.5],
+    ]
+
+    assert_array_almost_equal(wikipedia_results, bp, 4)
+
+
+def setup_module(module):
+    pytest.importorskip("numpy")

venv/lib/python3.10/site-packages/nltk/test/unit/test_json2csv_corpus.py

@@ -0,0 +1,210 @@
+# Natural Language Toolkit: Twitter client
+#
+# Copyright (C) 2001-2023 NLTK Project
+# Author: Lorenzo Rubio <[email protected]>
+# URL: <https://www.nltk.org/>
+# For license information, see LICENSE.TXT
+
+"""
+Regression tests for `json2csv()` and `json2csv_entities()` in Twitter
+package.
+"""
+from pathlib import Path
+
+import pytest
+
+from nltk.corpus import twitter_samples
+from nltk.twitter.common import json2csv, json2csv_entities
+
+
+def files_are_identical(pathA, pathB):
+    """
+    Compare two files, ignoring carriage returns,
+    leading whitespace, and trailing whitespace
+    """
+    f1 = [l.strip() for l in pathA.read_bytes().splitlines()]
+    f2 = [l.strip() for l in pathB.read_bytes().splitlines()]
+    return f1 == f2
+
+
+subdir = Path(__file__).parent / "files"
+
+
+@pytest.fixture
+def infile():
+    with open(twitter_samples.abspath("tweets.20150430-223406.json")) as infile:
+        return [next(infile) for x in range(100)]
+
+
+def test_textoutput(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.text.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.text.csv"
+    json2csv(infile, outfn, ["text"], gzip_compress=False)
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_metadata(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.tweet.csv.ref"
+    fields = [
+        "created_at",
+        "favorite_count",
+        "id",
+        "in_reply_to_status_id",
+        "in_reply_to_user_id",
+        "retweet_count",
+        "retweeted",
+        "text",
+        "truncated",
+        "user.id",
+    ]
+
+    outfn = tmp_path / "tweets.20150430-223406.tweet.csv"
+    json2csv(infile, outfn, fields, gzip_compress=False)
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_user_metadata(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.user.csv.ref"
+    fields = ["id", "text", "user.id", "user.followers_count", "user.friends_count"]
+
+    outfn = tmp_path / "tweets.20150430-223406.user.csv"
+    json2csv(infile, outfn, fields, gzip_compress=False)
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_hashtag(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.hashtag.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.hashtag.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id", "text"],
+        "hashtags",
+        ["text"],
+        gzip_compress=False,
+    )
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_usermention(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.usermention.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.usermention.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id", "text"],
+        "user_mentions",
+        ["id", "screen_name"],
+        gzip_compress=False,
+    )
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_media(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.media.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.media.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id"],
+        "media",
+        ["media_url", "url"],
+        gzip_compress=False,
+    )
+
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_url(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.url.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.url.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id"],
+        "urls",
+        ["url", "expanded_url"],
+        gzip_compress=False,
+    )
+
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_userurl(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.userurl.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.userurl.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id", "screen_name"],
+        "user.urls",
+        ["url", "expanded_url"],
+        gzip_compress=False,
+    )
+
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_place(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.place.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.place.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id", "text"],
+        "place",
+        ["name", "country"],
+        gzip_compress=False,
+    )
+
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_tweet_place_boundingbox(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.placeboundingbox.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.placeboundingbox.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id", "name"],
+        "place.bounding_box",
+        ["coordinates"],
+        gzip_compress=False,
+    )
+
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_retweet_original_tweet(tmp_path, infile):
+    ref_fn = subdir / "tweets.20150430-223406.retweet.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.retweet.csv"
+    json2csv_entities(
+        infile,
+        outfn,
+        ["id"],
+        "retweeted_status",
+        [
+            "created_at",
+            "favorite_count",
+            "id",
+            "in_reply_to_status_id",
+            "in_reply_to_user_id",
+            "retweet_count",
+            "text",
+            "truncated",
+            "user.id",
+        ],
+        gzip_compress=False,
+    )
+
+    assert files_are_identical(outfn, ref_fn)
+
+
+def test_file_is_wrong(tmp_path, infile):
+    """
+    Sanity check that file comparison is not giving false positives.
+    """
+    ref_fn = subdir / "tweets.20150430-223406.retweet.csv.ref"
+    outfn = tmp_path / "tweets.20150430-223406.text.csv"
+    json2csv(infile, outfn, ["text"], gzip_compress=False)
+    assert not files_are_identical(outfn, ref_fn)

venv/lib/python3.10/site-packages/nltk/test/unit/test_json_serialization.py

@@ -0,0 +1,95 @@
+import unittest
+
+from nltk.corpus import brown
+from nltk.jsontags import JSONTaggedDecoder, JSONTaggedEncoder
+from nltk.tag import (
+    AffixTagger,
+    BigramTagger,
+    BrillTagger,
+    BrillTaggerTrainer,
+    DefaultTagger,
+    NgramTagger,
+    PerceptronTagger,
+    RegexpTagger,
+    TrigramTagger,
+    UnigramTagger,
+)
+from nltk.tag.brill import nltkdemo18
+
+
+class TestJSONSerialization(unittest.TestCase):
+    def setUp(self):
+        self.corpus = brown.tagged_sents()[:35]
+        self.decoder = JSONTaggedDecoder()
+        self.encoder = JSONTaggedEncoder()
+        self.default_tagger = DefaultTagger("NN")
+
+    def test_default_tagger(self):
+        encoded = self.encoder.encode(self.default_tagger)
+        decoded = self.decoder.decode(encoded)
+
+        self.assertEqual(repr(self.default_tagger), repr(decoded))
+        self.assertEqual(self.default_tagger._tag, decoded._tag)
+
+    def test_regexp_tagger(self):
+        tagger = RegexpTagger([(r".*", "NN")], backoff=self.default_tagger)
+
+        encoded = self.encoder.encode(tagger)
+        decoded = self.decoder.decode(encoded)
+
+        self.assertEqual(repr(tagger), repr(decoded))
+        self.assertEqual(repr(tagger.backoff), repr(decoded.backoff))
+        self.assertEqual(tagger._regexps, decoded._regexps)
+
+    def test_affix_tagger(self):
+        tagger = AffixTagger(self.corpus, backoff=self.default_tagger)
+
+        encoded = self.encoder.encode(tagger)
+        decoded = self.decoder.decode(encoded)
+
+        self.assertEqual(repr(tagger), repr(decoded))
+        self.assertEqual(repr(tagger.backoff), repr(decoded.backoff))
+        self.assertEqual(tagger._affix_length, decoded._affix_length)
+        self.assertEqual(tagger._min_word_length, decoded._min_word_length)
+        self.assertEqual(tagger._context_to_tag, decoded._context_to_tag)
+
+    def test_ngram_taggers(self):
+        unitagger = UnigramTagger(self.corpus, backoff=self.default_tagger)
+        bitagger = BigramTagger(self.corpus, backoff=unitagger)
+        tritagger = TrigramTagger(self.corpus, backoff=bitagger)
+        ntagger = NgramTagger(4, self.corpus, backoff=tritagger)
+
+        encoded = self.encoder.encode(ntagger)
+        decoded = self.decoder.decode(encoded)
+
+        self.assertEqual(repr(ntagger), repr(decoded))
+        self.assertEqual(repr(tritagger), repr(decoded.backoff))
+        self.assertEqual(repr(bitagger), repr(decoded.backoff.backoff))
+        self.assertEqual(repr(unitagger), repr(decoded.backoff.backoff.backoff))
+        self.assertEqual(
+            repr(self.default_tagger), repr(decoded.backoff.backoff.backoff.backoff)
+        )
+
+    def test_perceptron_tagger(self):
+        tagger = PerceptronTagger(load=False)
+        tagger.train(self.corpus)
+
+        encoded = self.encoder.encode(tagger)
+        decoded = self.decoder.decode(encoded)
+
+        self.assertEqual(tagger.model.weights, decoded.model.weights)
+        self.assertEqual(tagger.tagdict, decoded.tagdict)
+        self.assertEqual(tagger.classes, decoded.classes)
+
+    def test_brill_tagger(self):
+        trainer = BrillTaggerTrainer(
+            self.default_tagger, nltkdemo18(), deterministic=True
+        )
+        tagger = trainer.train(self.corpus, max_rules=30)
+
+        encoded = self.encoder.encode(tagger)
+        decoded = self.decoder.decode(encoded)
+
+        self.assertEqual(repr(tagger._initial_tagger), repr(decoded._initial_tagger))
+        self.assertEqual(tagger._rules, decoded._rules)
+        self.assertEqual(tagger._training_stats, decoded._training_stats)

venv/lib/python3.10/site-packages/nltk/test/unit/test_metrics.py

@@ -0,0 +1,66 @@
+import unittest
+
+from nltk.metrics import (
+    BigramAssocMeasures,
+    QuadgramAssocMeasures,
+    TrigramAssocMeasures,
+)
+
+## Test the likelihood ratio metric
+
+_DELTA = 1e-8
+
+
+class TestLikelihoodRatio(unittest.TestCase):
+    def test_lr_bigram(self):
+        self.assertAlmostEqual(
+            BigramAssocMeasures.likelihood_ratio(2, (4, 4), 20),
+            2.4142743368419755,
+            delta=_DELTA,
+        )
+        self.assertAlmostEqual(
+            BigramAssocMeasures.likelihood_ratio(1, (1, 1), 1), 0.0, delta=_DELTA
+        )
+        self.assertRaises(
+            ValueError,
+            BigramAssocMeasures.likelihood_ratio,
+            *(0, (2, 2), 2),
+        )
+
+    def test_lr_trigram(self):
+        self.assertAlmostEqual(
+            TrigramAssocMeasures.likelihood_ratio(1, (1, 1, 1), (1, 1, 1), 2),
+            5.545177444479562,
+            delta=_DELTA,
+        )
+        self.assertAlmostEqual(
+            TrigramAssocMeasures.likelihood_ratio(1, (1, 1, 1), (1, 1, 1), 1),
+            0.0,
+            delta=_DELTA,
+        )
+        self.assertRaises(
+            ValueError,
+            TrigramAssocMeasures.likelihood_ratio,
+            *(1, (1, 1, 2), (1, 1, 2), 2),
+        )
+
+    def test_lr_quadgram(self):
+        self.assertAlmostEqual(
+            QuadgramAssocMeasures.likelihood_ratio(
+                1, (1, 1, 1, 1), (1, 1, 1, 1, 1, 1), (1, 1, 1, 1), 2
+            ),
+            8.317766166719343,
+            delta=_DELTA,
+        )
+        self.assertAlmostEqual(
+            QuadgramAssocMeasures.likelihood_ratio(
+                1, (1, 1, 1, 1), (1, 1, 1, 1, 1, 1), (1, 1, 1, 1), 1
+            ),
+            0.0,
+            delta=_DELTA,
+        )
+        self.assertRaises(
+            ValueError,
+            QuadgramAssocMeasures.likelihood_ratio,
+            *(1, (1, 1, 1, 1), (1, 1, 1, 1, 1, 2), (1, 1, 1, 1), 1),
+        )

venv/lib/python3.10/site-packages/nltk/test/unit/test_naivebayes.py

@@ -0,0 +1,21 @@
+import unittest
+
+from nltk.classify.naivebayes import NaiveBayesClassifier
+
+
+class NaiveBayesClassifierTest(unittest.TestCase):
+    def test_simple(self):
+        training_features = [
+            ({"nice": True, "good": True}, "positive"),
+            ({"bad": True, "mean": True}, "negative"),
+        ]
+
+        classifier = NaiveBayesClassifier.train(training_features)
+
+        result = classifier.prob_classify({"nice": True})
+        self.assertTrue(result.prob("positive") > result.prob("negative"))
+        self.assertEqual(result.max(), "positive")
+
+        result = classifier.prob_classify({"bad": True})
+        self.assertTrue(result.prob("positive") < result.prob("negative"))
+        self.assertEqual(result.max(), "negative")

venv/lib/python3.10/site-packages/nltk/test/unit/test_nombank.py

@@ -0,0 +1,27 @@
+"""
+Unit tests for nltk.corpus.nombank
+"""
+
+import unittest
+
+from nltk.corpus import nombank
+
+# Load the nombank once.
+nombank.nouns()
+
+
+class NombankDemo(unittest.TestCase):
+    def test_numbers(self):
+        # No. of instances.
+        self.assertEqual(len(nombank.instances()), 114574)
+        # No. of rolesets
+        self.assertEqual(len(nombank.rolesets()), 5577)
+        # No. of nouns.
+        self.assertEqual(len(nombank.nouns()), 4704)
+
+    def test_instance(self):
+        self.assertEqual(nombank.instances()[0].roleset, "perc-sign.01")
+
+    def test_framefiles_fileids(self):
+        self.assertEqual(len(nombank.fileids()), 4705)
+        self.assertTrue(all(fileid.endswith(".xml") for fileid in nombank.fileids()))

venv/lib/python3.10/site-packages/nltk/test/unit/test_pl196x.py

@@ -0,0 +1,13 @@
+import unittest
+
+import nltk
+from nltk.corpus.reader import pl196x
+
+
+class TestCorpusViews(unittest.TestCase):
+    def test_corpus_reader(self):
+        pl196x_dir = nltk.data.find("corpora/pl196x")
+        pl = pl196x.Pl196xCorpusReader(
+            pl196x_dir, r".*\.xml", textids="textids.txt", cat_file="cats.txt"
+        )
+        pl.tagged_words(fileids=pl.fileids(), categories="cats.txt")

venv/lib/python3.10/site-packages/nltk/test/unit/test_pos_tag.py

@@ -0,0 +1,83 @@
+"""
+Tests for nltk.pos_tag
+"""
+
+
+import unittest
+
+from nltk import pos_tag, word_tokenize
+
+
+class TestPosTag(unittest.TestCase):
+    def test_pos_tag_eng(self):
+        text = "John's big idea isn't all that bad."
+        expected_tagged = [
+            ("John", "NNP"),
+            ("'s", "POS"),
+            ("big", "JJ"),
+            ("idea", "NN"),
+            ("is", "VBZ"),
+            ("n't", "RB"),
+            ("all", "PDT"),
+            ("that", "DT"),
+            ("bad", "JJ"),
+            (".", "."),
+        ]
+        assert pos_tag(word_tokenize(text)) == expected_tagged
+
+    def test_pos_tag_eng_universal(self):
+        text = "John's big idea isn't all that bad."
+        expected_tagged = [
+            ("John", "NOUN"),
+            ("'s", "PRT"),
+            ("big", "ADJ"),
+            ("idea", "NOUN"),
+            ("is", "VERB"),
+            ("n't", "ADV"),
+            ("all", "DET"),
+            ("that", "DET"),
+            ("bad", "ADJ"),
+            (".", "."),
+        ]
+        assert pos_tag(word_tokenize(text), tagset="universal") == expected_tagged
+
+    def test_pos_tag_rus(self):
+        text = "Илья оторопел и дважды перечитал бумажку."
+        expected_tagged = [
+            ("Илья", "S"),
+            ("оторопел", "V"),
+            ("и", "CONJ"),
+            ("дважды", "ADV"),
+            ("перечитал", "V"),
+            ("бумажку", "S"),
+            (".", "NONLEX"),
+        ]
+        assert pos_tag(word_tokenize(text), lang="rus") == expected_tagged
+
+    def test_pos_tag_rus_universal(self):
+        text = "Илья оторопел и дважды перечитал бумажку."
+        expected_tagged = [
+            ("Илья", "NOUN"),
+            ("оторопел", "VERB"),
+            ("и", "CONJ"),
+            ("дважды", "ADV"),
+            ("перечитал", "VERB"),
+            ("бумажку", "NOUN"),
+            (".", "."),
+        ]
+        assert (
+            pos_tag(word_tokenize(text), tagset="universal", lang="rus")
+            == expected_tagged
+        )
+
+    def test_pos_tag_unknown_lang(self):
+        text = "모르겠 습니 다"
+        self.assertRaises(NotImplementedError, pos_tag, word_tokenize(text), lang="kor")
+        # Test for default kwarg, `lang=None`
+        self.assertRaises(NotImplementedError, pos_tag, word_tokenize(text), lang=None)
+
+    def test_unspecified_lang(self):
+        # Tries to force the lang='eng' option.
+        text = "모르겠 습니 다"
+        expected_but_wrong = [("모르겠", "JJ"), ("습니", "NNP"), ("다", "NN")]
+        assert pos_tag(word_tokenize(text)) == expected_but_wrong

venv/lib/python3.10/site-packages/nltk/test/unit/test_ribes.py

@@ -0,0 +1,246 @@
+from nltk.translate.ribes_score import corpus_ribes, word_rank_alignment
+
+
+def test_ribes_empty_worder():  # worder as in word order
+    # Verifies that these two sentences have no alignment,
+    # and hence have the lowest possible RIBES score.
+    hyp = "This is a nice sentence which I quite like".split()
+    ref = "Okay well that's neat and all but the reference's different".split()
+
+    assert word_rank_alignment(ref, hyp) == []
+
+    list_of_refs = [[ref]]
+    hypotheses = [hyp]
+    assert corpus_ribes(list_of_refs, hypotheses) == 0.0
+
+
+def test_ribes_one_worder():
+    # Verifies that these two sentences have just one match,
+    # and the RIBES score for this sentence with very little
+    # correspondence is 0.
+    hyp = "This is a nice sentence which I quite like".split()
+    ref = "Okay well that's nice and all but the reference's different".split()
+
+    assert word_rank_alignment(ref, hyp) == [3]
+
+    list_of_refs = [[ref]]
+    hypotheses = [hyp]
+    assert corpus_ribes(list_of_refs, hypotheses) == 0.0
+
+
+def test_ribes_two_worder():
+    # Verifies that these two sentences have two matches,
+    # but still get the lowest possible RIBES score due
+    # to the lack of similarity.
+    hyp = "This is a nice sentence which I quite like".split()
+    ref = "Okay well that's nice and all but the reference is different".split()
+
+    assert word_rank_alignment(ref, hyp) == [9, 3]
+
+    list_of_refs = [[ref]]
+    hypotheses = [hyp]
+    assert corpus_ribes(list_of_refs, hypotheses) == 0.0
+
+
+def test_ribes():
+    # Based on the doctest of the corpus_ribes function
+    hyp1 = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "which",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "always",
+        "obeys",
+        "the",
+        "commands",
+        "of",
+        "the",
+        "party",
+    ]
+    ref1a = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "that",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "will",
+        "forever",
+        "heed",
+        "Party",
+        "commands",
+    ]
+    ref1b = [
+        "It",
+        "is",
+        "the",
+        "guiding",
+        "principle",
+        "which",
+        "guarantees",
+        "the",
+        "military",
+        "forces",
+        "always",
+        "being",
+        "under",
+        "the",
+        "command",
+        "of",
+        "the",
+        "Party",
+    ]
+    ref1c = [
+        "It",
+        "is",
+        "the",
+        "practical",
+        "guide",
+        "for",
+        "the",
+        "army",
+        "always",
+        "to",
+        "heed",
+        "the",
+        "directions",
+        "of",
+        "the",
+        "party",
+    ]
+
+    hyp2 = [
+        "he",
+        "read",
+        "the",
+        "book",
+        "because",
+        "he",
+        "was",
+        "interested",
+        "in",
+        "world",
+        "history",
+    ]
+    ref2a = [
+        "he",
+        "was",
+        "interested",
+        "in",
+        "world",
+        "history",
+        "because",
+        "he",
+        "read",
+        "the",
+        "book",
+    ]
+
+    list_of_refs = [[ref1a, ref1b, ref1c], [ref2a]]
+    hypotheses = [hyp1, hyp2]
+
+    score = corpus_ribes(list_of_refs, hypotheses)
+
+    assert round(score, 4) == 0.3597
+
+
+def test_no_zero_div():
+    # Regression test for Issue 2529, assure that no ZeroDivisionError is thrown.
+    hyp1 = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "which",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "always",
+        "obeys",
+        "the",
+        "commands",
+        "of",
+        "the",
+        "party",
+    ]
+    ref1a = [
+        "It",
+        "is",
+        "a",
+        "guide",
+        "to",
+        "action",
+        "that",
+        "ensures",
+        "that",
+        "the",
+        "military",
+        "will",
+        "forever",
+        "heed",
+        "Party",
+        "commands",
+    ]
+    ref1b = [
+        "It",
+        "is",
+        "the",
+        "guiding",
+        "principle",
+        "which",
+        "guarantees",
+        "the",
+        "military",
+        "forces",
+        "always",
+        "being",
+        "under",
+        "the",
+        "command",
+        "of",
+        "the",
+        "Party",
+    ]
+    ref1c = [
+        "It",
+        "is",
+        "the",
+        "practical",
+        "guide",
+        "for",
+        "the",
+        "army",
+        "always",
+        "to",
+        "heed",
+        "the",
+        "directions",
+        "of",
+        "the",
+        "party",
+    ]
+
+    hyp2 = ["he", "read", "the"]
+    ref2a = ["he", "was", "interested", "in", "world", "history", "because", "he"]
+
+    list_of_refs = [[ref1a, ref1b, ref1c], [ref2a]]
+    hypotheses = [hyp1, hyp2]
+
+    score = corpus_ribes(list_of_refs, hypotheses)
+
+    assert round(score, 4) == 0.1688

venv/lib/python3.10/site-packages/nltk/test/unit/test_rte_classify.py

@@ -0,0 +1,94 @@
+import pytest
+
+from nltk import config_megam
+from nltk.classify.rte_classify import RTEFeatureExtractor, rte_classifier, rte_features
+from nltk.corpus import rte as rte_corpus
+
+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 TestRTEClassifier:
+    # Test the feature extraction method.
+    def test_rte_feature_extraction(self):
+        pairs = rte_corpus.pairs(["rte1_dev.xml"])[:6]
+        test_output = [
+            f"{key:<15} => {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))
+        assert 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)
+
+        assert extractor.hyp_words == {"member", "China", "SCO."}
+        assert extractor.overlap("word") == set()
+        assert extractor.overlap("ne") == {"China"}
+        assert extractor.hyp_extra("word") == {"member"}
+
+    # Test the RTE classifier training.
+    def test_rte_classification_without_megam(self):
+        # Use a sample size for unit testing, since we
+        # don't need to fully train these classifiers
+        clf = rte_classifier("IIS", sample_N=100)
+        clf = rte_classifier("GIS", sample_N=100)
+
+    def test_rte_classification_with_megam(self):
+        try:
+            config_megam()
+        except (LookupError, AttributeError) as e:
+            pytest.skip("Skipping tests with dependencies on MEGAM")
+        clf = rte_classifier("megam", sample_N=100)

venv/lib/python3.10/site-packages/nltk/test/unit/test_seekable_unicode_stream_reader.py

@@ -0,0 +1,86 @@
+import os
+from io import BytesIO
+
+import pytest
+
+from nltk.corpus.reader import SeekableUnicodeStreamReader
+
+
+def check_reader(unicode_string, encoding):
+    bytestr = unicode_string.encode(encoding)
+    stream = BytesIO(bytestr)
+    reader = SeekableUnicodeStreamReader(stream, encoding)
+
+    # Should open at the start of the file
+    assert reader.tell() == 0
+
+    # Compare original string to contents from `.readlines()`
+    assert unicode_string == "".join(reader.readlines())
+
+    # Should be at the end of the file now
+    stream.seek(0, os.SEEK_END)
+    assert reader.tell() == stream.tell()
+
+    reader.seek(0)  # go back to start
+
+    # Compare original string to contents from `.read()`
+    contents = ""
+    char = None
+    while char != "":
+        char = reader.read(1)
+        contents += char
+    assert unicode_string == contents
+
+
+# Call `check_reader` with a variety of input strings and encodings.
+ENCODINGS = ["ascii", "latin1", "greek", "hebrew", "utf-16", "utf-8"]
+
+STRINGS = [
+    """
+    This is a test file.
+    It is fairly short.
+    """,
+    "This file can be encoded with latin1. \x83",
+    """\
+    This is a test file.
+    Here's a blank line:
+
+    And here's some unicode: \xee \u0123 \uffe3
+    """,
+    """\
+    This is a test file.
+    Unicode characters: \xf3 \u2222 \u3333\u4444 \u5555
+    """,
+    """\
+    This is a larger file.  It has some lines that are longer \
+    than 72 characters.  It's got lots of repetition.  Here's \
+    some unicode chars: \xee \u0123 \uffe3 \ueeee \u2345
+
+    How fun!  Let's repeat it twenty times.
+    """
+    * 20,
+]
+
+
+@pytest.mark.parametrize("string", STRINGS)
+def test_reader(string):
+    for encoding in ENCODINGS:
+        # skip strings that can't be encoded with the current encoding
+        try:
+            string.encode(encoding)
+        except UnicodeEncodeError:
+            continue
+        check_reader(string, encoding)
+
+
+def test_reader_stream_closes_when_deleted():
+    reader = SeekableUnicodeStreamReader(BytesIO(b""), "ascii")
+    assert not reader.stream.closed
+    reader.__del__()
+    assert reader.stream.closed
+
+
+def teardown_module(module=None):
+    import gc
+
+    gc.collect()

venv/lib/python3.10/site-packages/nltk/test/unit/test_senna.py

@@ -0,0 +1,112 @@
+"""
+Unit tests for Senna
+"""
+
+import unittest
+from os import environ, path, sep
+
+from nltk.classify import Senna
+from nltk.tag import SennaChunkTagger, SennaNERTagger, SennaTagger
+
+# 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)