Modify nmr/_main.py, nmr/nmr.py, test/test_huge.py, test/test_nmr.py,…

… test/test_sign.py

nmr/_main.py

@@ -84,7 +84,7 @@ def run(self, i: Any) -> None:
             if self._type_class and isinstance(i, int):
                 value = [i]
             else:
-                value = self.nmr.encode_to_name(i)
+                value = self.nmr._encode_to_name(i)
 
             if self._type_class:
                 value = [str(self._type_class.int_to_type(v)) for v in value]
@@ -106,7 +106,7 @@ def run(self, i: Any) -> None:
     def rnd(self) -> None:
         for i in range(self.random_count):
             r = int(10 ** random.uniform(0, 50))
-            print(f"{r}:", *self.nmr.encode_to_name(r))
+            print(f"{r}:", *self.nmr._encode_to_name(r))
 
     def group_args(self) -> Iterator[int | str | list[int | str]]:
         iargs = (types.try_to_int(a) for a in self.arguments or ())

nmr/nmr.py

@@ -53,21 +53,15 @@ def __init__(
         self._count_words = count_words.CountWords(self.n).count
         self.inverse = {w: i for i, w in enumerate(self.words)}
 
-    def encode_to_name(self, num: int) -> Sequence[str]:
+    def _encode_to_name(self, num: int) -> Sequence[str]:
         if num < 0:
             raise ValueError("Only accepts non-negative numbers")
         return [self.words[i] for i in self._to_digits(num)]
 
     def decode_from_name(self, name: Sequence[str]) -> int:
         name = list(name)
-        if len(set(name)) != len(name):
-            raise ValueError("Repeated words not allowed")
-
-        try:
-            indexes = [self.inverse[w] for w in reversed(name)]
-        except KeyError:
-            raise KeyError(*sorted(set(name) - set(self.inverse))) from None
-
+        _check_dupes(name)
+        indexes = [self.inverse[w] for w in reversed(name)]
         return self._from_digits(list(self._redupe(indexes))[::-1])
 
     def is_name(self, s: Sequence[str]) -> bool:
@@ -79,7 +73,7 @@ def name_to_type(self, name: Sequence[str]) -> str:
 
     def type_to_name(self, s: str) -> Sequence[str]:
         index = types.type_to_index(s)
-        return self.encode_to_name(index)
+        return self._encode_to_name(index)
 
     @property
     def n(self) -> int:

test/test_huge.py

@@ -6,15 +6,15 @@
 def test_huge_unsigned():
     maxint = nmr._count_words() - 1
     expected = ["the", "of", "and", "to", "a", "in", "for", "on"]
-    assert nmr.encode_to_name(maxint)[:8] == expected
+    assert nmr._encode_to_name(maxint)[:8] == expected
 
     expected = ["smile", "armed", "laura", "tokyo", "candy", "tiger", "boost", "moral"]
-    assert nmr.encode_to_name(maxint)[-8:] == expected
+    assert nmr._encode_to_name(maxint)[-8:] == expected
     with pytest.raises(ValueError):
-        nmr.encode_to_name(maxint + 1)
+        nmr._encode_to_name(maxint + 1)
 
     expected = ["the"]
-    assert nmr.encode_to_name(0) == expected
+    assert nmr._encode_to_name(0) == expected
 
 
 MAX = int(

test/test_nmr.py

@@ -52,7 +52,7 @@ def count(n, i):
 
 @pytest.mark.parametrize("number, words", _STABILITY_TABLE)
 def test_stability(number, words):
-    actual_words = nmr.encode_to_name(number)
+    actual_words = nmr._encode_to_name(number)
     if actual_words != words:
         print(actual_words)
     assert actual_words == words

test/test_sign.py

@@ -9,14 +9,14 @@ def test_all_unsigned(n):
     m = N._count_words(n)
 
     for i in range(m):
-        words = N.encode_to_name(i)
+        words = N._encode_to_name(i)
         assert len(words) == len(set(words))
         assert N.decode_from_name(words) == i, str(words)
 
     err = "Only accepts non-negative numbers"
     with pytest.raises(ValueError, match=err):
-        N.encode_to_name(-1)
+        N._encode_to_name(-1)
 
     err = f"Cannot represent {m} in base {n}"
     with pytest.raises(ValueError, match=err):
-        N.encode_to_name(m)
+        N._encode_to_name(m)