textslinger 0.2.0__tar.gz → 0.2.3__tar.gz

{textslinger-0.2.0/textslinger.egg-info → textslinger-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: textslinger
-Version: 0.2.0
+Version: 0.2.3
 Summary: TextSlinger: Fast and accurate text predictions in Python
 Author-email: Keith Vertanen <vertanen@mtu.edu>, Dylan Gaines <dgaine20@kennesaw.edu>, Soufia Bahmani <sbahmani@mtu.edu>
 License-Expression: MIT

{textslinger-0.2.0 → textslinger-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ requires = ["setuptools>=77.0.3", "wheel>=0.37.1"]
 
 [project]
 name = "textslinger"
-version = "0.2.0"
+dynamic = ["version"]
 authors = [
     {name="Keith Vertanen", email="vertanen@mtu.edu"},
     {name="Dylan Gaines", email="dgaine20@kennesaw.edu"},
@@ -16,14 +16,14 @@ license-files = ["LICENSE"]
 license = "MIT"
 requires-python = ">=3.10,<3.11"
 classifiers = [
-    'Development Status :: 3 - Alpha',
-    'Topic :: Scientific/Engineering :: Human Machine Interfaces',
-    'Natural Language :: English',
-    'Intended Audience :: Science/Research',
-    'Intended Audience :: End Users/Desktop',
-    'Intended Audience :: Developers',
-    'Programming Language :: Python',
-    'Programming Language :: Python :: 3.10',
+    "Development Status :: 3 - Alpha",
+    "Topic :: Scientific/Engineering :: Human Machine Interfaces",
+    "Natural Language :: English",
+    "Intended Audience :: Science/Research",
+    "Intended Audience :: End Users/Desktop",
+    "Intended Audience :: Developers",
+    "Programming Language :: Python",
+    "Programming Language :: Python :: 3.10",
 ]
 
 dependencies = [
@@ -60,21 +60,21 @@ release = [
 ]
 
 [project.urls]
-"Homepage" = "https://github.com/kdv123/textslinger"
-"Source" = "https://github.com/kdv123/textslinger"
+Homepage = "https://github.com/kdv123/textslinger"
+Source = "https://github.com/kdv123/textslinger"
 
 [tool.setuptools]
-# https://setuptools.pypa.io/en/latest/userguide/pyproject_config.html
 platforms = ["Linux", "Windows", "Mac OS-X"]
 include-package-data = true
 zip-safe = true
 
-# Python modules and packages that are included in the
-# distribution package (and therefore become importable)
+[tool.setuptools.dynamic]
+version = {attr = "textslinger.__version__"}
+
+# Python modules and packages included in the distribution
 [tool.setuptools.packages.find]
 exclude = ["examples", "scripts"]
 
 [tool.black]
-line-length = 88
-target-version = ["py310"]
-
+line-length = 100
+target-version = ["py310"]

textslinger-0.2.3/tests/conftest.py

@@ -0,0 +1,65 @@
+"""
+For configuration options related to running the test suite
+"""
+
+import pytest
+from textslinger.helpers import Device, Precision
+
+
+def pytest_addoption(parser):
+    parser.addoption("--device", type=Device, choices=list(Device), default=Device.CPU)
+    parser.addoption(
+        "--precision", type=Precision, choices=list(Precision), default=Precision.FP32
+    )
+    parser.addoption(
+        "--run-optional",
+        action="store_true",
+        default=False,
+        help="Run optional tests that are skipped by default",
+    )
+    parser.addoption(
+        "--run-long",
+        action="store_true",
+        default=False,
+        help="Run long tests that are skipped by default",
+    )
+    parser.addoption(
+        "--rewrite-ref-files",
+        action="store_true",
+        default=False,
+        help="Rewrite reference files, e.g. files with log probabilities obtained from a model",
+    )
+
+
+def pytest_runtest_setup(item):
+    # Skip optional tests by default
+    if "optional" in item.keywords and not item.config.getoption("--run-optional"):
+        pytest.skip("Skipping optional test by default")
+
+    # Skip long tests by default unless --run-long is provided
+    if "long" in item.keywords and not item.config.getoption("--run-long"):
+        pytest.skip("Skipping long test by default")
+
+
+@pytest.fixture(scope="session")
+def device(request):
+    """
+    Fixture to determine whether tests run on auto, cpu, cuda, or mps
+    """
+    return request.config.getoption("--device")
+
+
+@pytest.fixture(scope="session")
+def precision(request):
+    """
+    Fixture to set the precision models are loaded with
+    """
+    return request.config.getoption("--precision")
+
+
+@pytest.fixture(scope="session")
+def rewrite_ref_files(request):
+    """
+    Fixture to request some tests rewrite their reference files
+    """
+    return request.config.getoption("--rewrite-ref-files")

{textslinger-0.2.0 → textslinger-0.2.3}/tests/test_causal_byte.py

@@ -1,21 +1,30 @@
 from textslinger.causal_byte import (
     CausalByteLanguageModel,
     InvalidLanguageModelException,
+    DecodeConfigByte,
 )
 import pytest
-from tests.test_constants import (
-    BYTE_LLM,
-    BYTE_LLM_PARAMS,
-    BYTE_LLM_TOKENS,
-    SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS,
-    SYMBOLS_LOWERCASE_SPACE,
+from tests.helpers import (
+    check_match,
+    check_sum_to_one,
+    suppress_stderr_fd,
+    read_float_list,
 )
-from tests.helpers import check_match, check_sum_to_one, suppress_stderr_fd
+from tests.test_constants import *
+from textslinger.eval_helper import (
+    load_phrases_plaintext,
+    filter_phrases,
+    normalize_phrases,
+)
+import copy
 
 # NOTE: if the device is changed to MPS, many tests fail because the probabilities and/or hypotheses change
 # Currently set high enough to pass on various CPUs and GPUs
 EPSILON_BYTE_PREDICT = 0.04
 
+# Higher epsilon for scoring items and comparing total log prob
+EPSILON_BYTE_LOG_PROB = 0.2
+
 
 @pytest.fixture(scope="module")
 def shared_lm(device, precision):
@@ -34,6 +43,58 @@ def shared_lm(device, precision):
     yield lm
 
 
+@pytest.fixture(scope="module")
+def config_default():
+    """
+    A default set for our tests since we don't want to rely on the defaults in the class
+    since they might get changed
+    """
+    config = DecodeConfigByte()
+    config.max_word_hypotheses = 256
+    config.beam_best = 8.0
+    config.beam_search_max = 300
+    config.max_word_len = 25
+    config.lm_scale = 1.0
+    config.ins_penalty = -20.0
+    config.ins_after_input_penalty = 0.0
+    config.del_penalty = -20.0
+    config.batch_size = None
+    yield config
+
+
+@pytest.fixture(scope="module")
+def config_narrow(config_default):
+    """
+    Narrow beam for fast decoding
+    """
+    config = copy.deepcopy(config_default)
+    config.beam_best = 5.0
+    config.beam_search_max = 4
+    yield config
+
+
+@pytest.fixture(scope="module")
+def config_narrower(config_default):
+    """
+    Narrow beam for fast decoding
+    """
+    config = copy.deepcopy(config_default)
+    config.beam_best = 1.3
+    config.beam_search_max = 4
+    yield config
+
+
+@pytest.fixture(scope="module")
+def config_narrowest(config_default):
+    """
+    Narrow beam for fast decoding
+    """
+    config = copy.deepcopy(config_default)
+    config.beam_best = 0.5
+    config.beam_search_max = 4
+    yield config
+
+
 def test_bogus_model_name():
     """
     Attempt to load with a bogus model name
@@ -65,9 +126,7 @@ def test_lowercase_symbol_set(shared_lm):
 
     # First of all size should be correct
     assert len(shared_lm.symbol_set) == len(SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS)
-    assert len(shared_lm.symbol_set_lower) == len(
-        SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS
-    )
+    assert len(shared_lm.symbol_set_lower) == len(SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS)
 
     # Check all symbols are in both the normal and lowercase symbol sets
     for symbol in SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS:
@@ -292,7 +351,7 @@ def test_predict_symbol_endings(shared_lm):
     check_sum_to_one(predictions)
 
 
-def test_predict_words_no_context(shared_lm):
+def test_predict_words_no_context(shared_lm, config_narrowest):
     """
     Make word predictions in the middle of a word that is likely a contraction
     """
@@ -300,14 +359,13 @@ def test_predict_words_no_context(shared_lm):
     references = ["title", "what", "let"]
     predictions = shared_lm.predict_words(
         left_context="",
-        beam_logp_best=0.5,
-        beam_search_max=4,
+        config=config_narrowest,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_full_word(shared_lm):
+def test_predict_words_full_word(shared_lm, config_narrowest):
     """
     Make word predictions at the end of a word but merge word end symbols
     This causes all the end of word symbol hypotheses to collapse into blank hypothesis
@@ -316,14 +374,13 @@ def test_predict_words_full_word(shared_lm):
     references = [""]
     predictions = shared_lm.predict_words(
         left_context="Bye bye",
-        beam_logp_best=5.0,
-        beam_search_max=4,
+        config=config_narrowest,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_full_word_include_ending(shared_lm):
+def test_predict_words_full_word_include_ending(shared_lm, config_narrow):
     """
     Make word predictions at the end of a word and request the ending symbol be included in results
     """
@@ -331,15 +388,14 @@ def test_predict_words_full_word_include_ending(shared_lm):
     references = [" ", ",", "!", ".", "?"]
     predictions = shared_lm.predict_words(
         left_context="Bye bye",
-        beam_logp_best=5.0,
-        beam_search_max=4,
+        config=config_narrow,
         include_ending_symbol=True,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_partial_word_with_log_probs(shared_lm):
+def test_predict_words_partial_word_with_log_probs(shared_lm, config_narrow):
     """
     Make word predictions at near the end of a word
     This also checks the log probs in the results
@@ -348,15 +404,14 @@ def test_predict_words_partial_word_with_log_probs(shared_lm):
     references = [("e", -0.11844532689588708), ("", -4.672425501089463)]
     predictions = shared_lm.predict_words(
         left_context="Bye by",
-        beam_logp_best=5.0,
-        beam_search_max=4,
+        config=config_narrow,
         return_log_probs=True,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references, epsilon=EPSILON_BYTE_PREDICT)
 
 
-def test_predict_words_partial_word_include_ending(shared_lm):
+def test_predict_words_partial_word_include_ending(shared_lm, config_narrow):
     """
     Make word predictions at near the end of a word and request the ending symbol be included in results
     """
@@ -364,60 +419,59 @@ def test_predict_words_partial_word_include_ending(shared_lm):
     references = ["e ", "e,", "e!", "e.", " ", "e?"]
     predictions = shared_lm.predict_words(
         left_context="Bye by",
-        beam_logp_best=5.0,
-        beam_search_max=4,
+        config=config_narrow,
         include_ending_symbol=True,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_contraction(shared_lm):
+def test_predict_words_contraction(shared_lm, config_narrower):
     """
     Make word predictions in the middle of a word that is likely a contraction
     """
     shared_lm.change_symbol_set(SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS)
-    references = ["d", "dn't", "g"]
+    references = ["d", "dn't", "e", "", "n"]
     predictions = shared_lm.predict_words(
         left_context="I do not know why you di",
-        beam_logp_best=1.3,
+        config=config_narrower,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_contraction_no_apostrophe(shared_lm):
+def test_predict_words_contraction_no_apostrophe(shared_lm, config_narrower):
     """
     Make word predictions in the middle of a word that is likely a contraction
     This version doesn't have apostrophe in the valid symbols
     """
     shared_lm.change_symbol_set(SYMBOLS_LOWERCASE_SPACE)
-    references = ["d", "", "n"]
+    references = ["d", "e", "", "n"]
     predictions = shared_lm.predict_words(
         left_context="I do not know why you di",
-        beam_logp_best=1.3,
+        config=config_narrower,
     )
     check_match(predictions, references, expected_predictions=len(references))
 
 
-def test_predict_words_contraction_prune_max_words(shared_lm):
+def test_predict_words_contraction_prune_max_words(shared_lm, config_narrower):
     """
     Make word predictions in the middle of a word that is likely a contraction
     This version prunes based on the maximum number of word hypotheses
     """
     shared_lm.change_symbol_set(SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS)
-    references = ["", "n", "m"]
-    max_word_hypos = 3
+    config = copy.deepcopy(config_narrower)
+    config.max_word_hypotheses = 3
+    references = ["e", "", "n"]
     predictions = shared_lm.predict_words(
         left_context="I do not know why you di",
-        beam_logp_best=1.3,
-        max_word_hypotheses=max_word_hypos,
+        config=config,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
-    check_match(predictions, references, expected_predictions=max_word_hypos)
+    check_match(predictions, references, expected_predictions=config.max_word_hypotheses)
 
 
-def test_predict_words_mixed_case(shared_lm):
+def test_predict_words_mixed_case(shared_lm, config_narrower):
     """
     Try and predict a word that is in mixed case
     """
@@ -425,15 +479,14 @@ def test_predict_words_mixed_case(shared_lm):
     references = ["iPhone", "Apple"]
     predictions = shared_lm.predict_words(
         left_context="On Friday Apple released their latest phone the ",
-        beam_logp_best=1.3,
-        beam_search_max=4,
+        config=config_narrower,
         predict_lower=False,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_extra_endings(shared_lm):
+def test_predict_words_extra_endings(shared_lm, config_narrowest):
     """
     Predict the very end of a word but with extra word endings enabled
     """
@@ -441,31 +494,30 @@ def test_predict_words_extra_endings(shared_lm):
     references = ["y", ""]
     predictions = shared_lm.predict_words(
         left_context="How are you feeling toda",
-        beam_logp_best=0.5,
+        config=config_narrowest,
         word_end_symbols=[" ", ".", ",", "!", "?"],
-        beam_search_max=4,
     )
     check_match(predictions, references, expected_predictions=len(references))
 
 
-def test_predict_words_extra_endings_batch(shared_lm):
+def test_predict_words_extra_endings_batch(shared_lm, config_narrowest):
     """
     Predict the very end of a word but with extra word endings enabled
     Uses a smaller mini batch size during inference
     """
     shared_lm.change_symbol_set(SYMBOLS_LOWERCASE_SPACE_APOSTROPHE_ENDINGS)
+    config = copy.deepcopy(config_narrowest)
+    config.batch_size = 8
     references = ["y", ""]
     predictions = shared_lm.predict_words(
         left_context="How are you feeling toda",
-        beam_logp_best=0.5,
+        config=config,
         word_end_symbols=[" ", ".", ",", "!", "?"],
-        beam_search_max=4,
-        batch_size=8,
     )
     check_match(predictions, references, expected_predictions=len(references))
 
 
-def test_predict_words_curly_apostrophe(shared_lm):
+def test_predict_words_curly_apostrophe(shared_lm, config_narrowest):
     """
     Try and predict the ending of a word with curly apostrophe
     """
@@ -473,14 +525,13 @@ def test_predict_words_curly_apostrophe(shared_lm):
     references = ["'t", "t", ""]
     predictions = shared_lm.predict_words(
         left_context="You didn’t do it and I also didn",
-        beam_logp_best=0.5,
+        config=config_narrowest,
         word_end_symbols=[" ", ".", ",", "!", "?"],
-        beam_search_max=4,
     )
     check_match(predictions, references, expected_predictions=len(references))
 
 
-def test_predict_words_english(shared_lm):
+def test_predict_words_english(shared_lm, config_narrowest):
     """
     Prediction to compare with that uses English left context
     """
@@ -489,14 +540,13 @@ def test_predict_words_english(shared_lm):
     references = ["d"]
     predictions = shared_lm.predict_words(
         left_context="Good day and I love you very much. Ad",
-        beam_logp_best=0.5,
-        beam_search_max=4,
+        config=config_narrowest,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
 
 
-def test_predict_words_spanish(shared_lm):
+def test_predict_words_spanish(shared_lm, config_narrowest):
     """
     Try and predict a word in Spanish using Spanish left context
     """
@@ -505,8 +555,142 @@ def test_predict_words_spanish(shared_lm):
     references = ["ios"]
     predictions = shared_lm.predict_words(
         left_context="¡Buen día y te amo mucho! Ad",
-        beam_logp_best=0.5,
-        beam_search_max=4,
+        config=config_narrowest,
         word_end_symbols=[" ", ".", ",", "!", "?"],
     )
     check_match(predictions, references)
+
+
+def test_score_item(shared_lm):
+    """
+    Test computing the log prob (base e) for a single sentence
+    """
+    score = shared_lm.score_item(STR_PEOPLE_SHOCKED)
+    assert score == pytest.approx(LOG_PROB_BYTE_PEOPLE_SHOCKED, abs=EPSILON_BYTE_LOG_PROB)
+
+
+def test_score_item_and_extension(shared_lm):
+    """
+    Score sentence and then again with additional character on end
+    Verify that this matches adding prediction of that single character
+    """
+    add_char = " "
+    score = shared_lm.score_item(STR_PEOPLE_SHOCKED)
+    score_plus_space = shared_lm.score_item(STR_PEOPLE_SHOCKED + add_char)
+    assert score > score_plus_space
+    char_to_log_prob = dict(
+        shared_lm.predict(evidence=list(STR_PEOPLE_SHOCKED), unnormalized_logprobs=True)
+    )
+    score_plus_predict = score + char_to_log_prob[add_char]
+    assert score_plus_predict == pytest.approx(score_plus_space, abs=EPSILON_BYTE_LOG_PROB)
+
+
+def test_score_items_identical(shared_lm):
+    """
+    Test computing the log prob (base e) for multiple identical sentences
+    Do inference in one big batch
+    """
+    num_repeats = 7
+    items = [STR_PEOPLE_SHOCKED] * num_repeats
+    scores = shared_lm.score_items(items=items, batch_size=None)
+    assert len(scores) == num_repeats
+    for score in scores:
+        assert score == pytest.approx(LOG_PROB_BYTE_PEOPLE_SHOCKED, abs=EPSILON_BYTE_LOG_PROB)
+
+
+def test_score_items_identical_batch_size1(shared_lm):
+    """
+    Test computing the log prob (base e) for multiple identical sentences
+    Do inference one item at a time
+    """
+    num_repeats = 7
+    items = [STR_PEOPLE_SHOCKED] * num_repeats
+    scores = shared_lm.score_items(items=items, batch_size=1)
+    assert len(scores) == num_repeats
+    for score in scores:
+        assert score == pytest.approx(LOG_PROB_BYTE_PEOPLE_SHOCKED, abs=EPSILON_BYTE_LOG_PROB)
+
+
+def test_score_items_identical_batch_size2(shared_lm):
+    """
+    Test computing the log prob (base e) for multiple identical sentences
+    Do inference one item at a time
+    """
+    num_repeats = 7
+    items = [STR_PEOPLE_SHOCKED] * num_repeats
+    scores = shared_lm.score_items(items=items, batch_size=2)
+    assert len(scores) == num_repeats
+    for score in scores:
+        assert score == pytest.approx(LOG_PROB_BYTE_PEOPLE_SHOCKED, abs=EPSILON_BYTE_LOG_PROB)
+
+
+def test_score_items_alternating(shared_lm):
+    """
+    Test computing the log prob (base e) for multiple alternating sentences
+    """
+    # Create a list with alternating sentences with known log probs
+    num_repeats = 7
+    items = []
+    for _ in range(num_repeats):
+        items.append(STR_PEOPLE_SHOCKED)
+        items.append(STR_LOWERCASE_LETTERS_SPACE)
+    scores = shared_lm.score_items(items=items)
+
+    for i in range(len(items)):
+        if i % 2 == 0:
+            assert scores[i] == pytest.approx(
+                LOG_PROB_BYTE_PEOPLE_SHOCKED, abs=EPSILON_BYTE_LOG_PROB
+            )
+        else:
+            assert scores[i] == pytest.approx(
+                LOG_PROB_BYTE_LOWERCASE_LETTERS_SPACE, abs=EPSILON_BYTE_LOG_PROB
+            )
+
+
+def test_score_items_empty(shared_lm):
+    """
+    Test asking for scoring of empty list
+    """
+    scores = shared_lm.score_items(items=[])
+    assert len(scores) == 0
+
+
+def test_score_items_order(shared_lm):
+    """
+    Score sentences that have an obvious order of probability
+    """
+    items = [
+        "The United States of America",
+        "the united states of america",
+        "The United State of America",
+        "The United State of Alabama",
+        "The United State of Amerika",
+        "The United State of_Amerika",
+    ]
+    scores = shared_lm.score_items(items=items)
+    print(scores)
+    for i in range(1, len(items)):
+        assert scores[i - 1] > scores[i]
+
+
+@pytest.mark.long
+def test_score_items_comm2(shared_lm, rewrite_ref_files):
+    """
+    Compute the log prob of each sentence in the COMM2 test set
+    We filter to sentences without numbers, lowercase, and strip symbols other than apostrophe
+    Compare against log probs obtained from a previous run of the model
+    """
+    phrases = load_phrases_plaintext(filename=COMM2_PHRASES, drop_first_col=True)
+    phrases = filter_phrases(phrases=phrases, drop_numbers=True)
+    phrases, _ = normalize_phrases(phrases=phrases, lower=True, strip_symbols=True)
+    scores = shared_lm.score_items(items=phrases, batch_size=32)
+    if rewrite_ref_files:
+        print(f"Rewriting log probs to: {COMM2_BYTE_LOG_PROBS}")
+        with open(COMM2_BYTE_LOG_PROBS, "w") as f:
+            for lp in scores:
+                f.write(f"{lp}\n")
+    known_log_probs = read_float_list(filename=COMM2_BYTE_LOG_PROBS)
+    assert len(scores) == len(known_log_probs)
+    for i in range(len(scores)):
+        # Note: we need a bit larger epsilon to pass on both CPU and CUDA devices
+        assert scores[i] == pytest.approx(known_log_probs[i], abs=2.0)

{textslinger-0.2.0 → textslinger-0.2.3}/tests/test_causal_subword_local.py

@@ -67,9 +67,7 @@ class TestCausalSubwordLocal(unittest.TestCase):
             "Distribution should not be uniform even without context.",
         )
 
-        self.assertAlmostEqual(
-            sum(probs), 1, places=3, msg="Probabilities should sum to 1."
-        )
+        self.assertAlmostEqual(sum(probs), 1, places=3, msg="Probabilities should sum to 1.")
 
     def test_predict_middle_of_word(self):
         symbol_probs = self.lm.predict(evidence=list("This is a tes"))
@@ -77,9 +75,7 @@ class TestCausalSubwordLocal(unittest.TestCase):
 
         self.assertTrue(len(set(probs)) > 1, "Distribution should not be uniform.")
 
-        self.assertAlmostEqual(
-            sum(probs), 1, places=3, msg="Probabilities should sum to 1."
-        )
+        self.assertAlmostEqual(sum(probs), 1, places=3, msg="Probabilities should sum to 1.")
 
         most_likely_sym, most_likely_prob = symbol_probs[0]
         self.assertAlmostEqual(
@@ -97,15 +93,11 @@ class TestCausalSubwordLocal(unittest.TestCase):
 
     """Word Prediction Tests"""
 
-    @pytest.mark.hf
     def test_local_model_predict_words_small_beam(self):
 
         # Small, fast query: we only assert that we get at least one completion.
         words = self.lm.predict_words(
             "the ",
-            nbest=3,
-            max_word_len=12,
-            max_word_hypotheses=64,
             return_log_probs=False,
         )
         assert isinstance(words, list) and len(words) > 0

{textslinger-0.2.0 → textslinger-0.2.3}/tests/test_causal_subword_repoid.py

@@ -22,7 +22,5 @@ def test_load_predict_word():
         device=Device.CPU,
         precision=Precision.FP32,
     )
-    words = lm.predict_words(
-        "a ", nbest=2, max_word_len=10, max_word_hypotheses=32, return_log_probs=False
-    )
+    words = lm.predict_words("a ", nbest=2, return_log_probs=False)
     assert isinstance(words, list) and len(words) > 0