Clean up, add analyze target

pjkundert · pjkundert · commit 1a2261ddf739 · 2025-08-21T09:21:27.000-06:00
diff --git a/MANIFEST.in b/MANIFEST.in
@@ -1,7 +1,6 @@
 include LICENSE
 include README.md
 include requirements.txt
-include requirements/slip39.txt
 include requirements/cli.txt
 include requirements/tests.txt
 include requirements/docs.txt
diff --git a/Makefile b/Makefile
@@ -31,7 +31,7 @@ export NIX_OPTS		?=
 help:
 	@$(SPHINXBUILD) -M help "$(SOURCEDIR)" "$(BUILDDIR)" $(SPHINXOPTS) $(O)
 
-.PHONY: help wheel install venv Makefile FORCE
+.PHONY: help wheel install test analyze venv Makefile FORCE
 
 
 wheel:			$(WHEEL)
@@ -55,6 +55,11 @@ unit-%:
 test:
 	$(PYTEST) $(PYTEST_OPTS) tests
 
+analyze:
+	$(PYTHON) -m flake8 --color never -j 1 --max-line-length=250 \
+	  --ignore=W503,W504,E201,E202,E223,E226 \
+	  hdwallet
+
 # 
 # Nix and VirtualEnv build, install and activate
 #
diff --git a/hdwallet/cli/generate/seed.py b/hdwallet/cli/generate/seed.py
@@ -30,12 +30,12 @@ def generate_seed(**kwargs) -> None:
             if not MNEMONICS.mnemonic(name="Electrum-V2").is_valid(
                 mnemonic=kwargs.get("mnemonic"), mnemonic_type=kwargs.get("mnemonic_type")
             ):
-                click.echo(click.style(f"Invalid Electrum-V2 mnemonic"), err=True)
+                click.echo(click.style("Invalid Electrum-V2 mnemonic"), err=True)
                 sys.exit()
         elif kwargs.get("client") != SLIP39Seed.name():  # SLIP39 supports any 128-, 256- or 512-bit Mnemonic
             mnemonic_name: str = "BIP39" if kwargs.get("client") == CardanoSeed.name() else kwargs.get("client")
             if not MNEMONICS.mnemonic(name=mnemonic_name).is_valid(mnemonic=kwargs.get("mnemonic")):
-                click.echo(click.style(f"Invalid {mnemonic_name} mnemonic {kwargs.get('mnemonic')!r}"), err=True)
+                click.echo(click.style(f"Invalid {mnemonic_name} mnemonic"), err=True)
                 sys.exit()
 
         if kwargs.get("client") == BIP39Seed.name():
diff --git a/hdwallet/entropies/ientropy.py b/hdwallet/entropies/ientropy.py
@@ -18,7 +18,7 @@
 
 
 class IEntropy:
-    
+
     _entropy: str
     _strength: int
 
@@ -148,4 +148,4 @@ def are_entropy_bits_enough(self, entropy: Union[bytes, int]) -> bool:
         """
 
         if self.name() != "Electrum-V2":
-            raise NotImplemented
+            raise NotImplementedError
diff --git a/hdwallet/mnemonics/__init__.py b/hdwallet/mnemonics/__init__.py
@@ -9,20 +9,20 @@
 )
 
 from ..exceptions import MnemonicError
-from .algorand import (
+from .algorand import (  # noqa: F401
     AlgorandMnemonic, ALGORAND_MNEMONIC_WORDS, ALGORAND_MNEMONIC_LANGUAGES
 )
-from .bip39 import (
+from .bip39 import (  # noqa: F401
     BIP39Mnemonic, BIP39_MNEMONIC_WORDS, BIP39_MNEMONIC_LANGUAGES
 )
-from .slip39 import (
+from .slip39 import (  # noqa: F401
     SLIP39Mnemonic, SLIP39_MNEMONIC_WORDS, SLIP39_MNEMONIC_LANGUAGES
 )
-from .electrum import (
+from .electrum import (  # noqa: F401
     ElectrumV1Mnemonic, ELECTRUM_V1_MNEMONIC_WORDS, ELECTRUM_V1_MNEMONIC_LANGUAGES,
     ElectrumV2Mnemonic, ELECTRUM_V2_MNEMONIC_WORDS, ELECTRUM_V2_MNEMONIC_LANGUAGES, ELECTRUM_V2_MNEMONIC_TYPES
 )
-from .monero import (
+from .monero import (  # noqa: F401
     MoneroMnemonic, MONERO_MNEMONIC_WORDS, MONERO_MNEMONIC_LANGUAGES
 )
 from .imnemonic import IMnemonic
@@ -44,6 +44,8 @@ class MNEMONICS:
     +--------------+------------------------------------------------------------------------+
     | BIP39        |  :class:`hdwallet.mnemonics.bip39.mnemonic.BIP39Mnemonic`              |
     +--------------+------------------------------------------------------------------------+
+    | SLIP39       |  :class:`hdwallet.mnemonics.slip39.mnemonic.SLIP39Mnemonic`            |
+    +--------------+------------------------------------------------------------------------+
     | Electrum-V1  |  :class:`hdwallet.mnemonics.electrum.v1.mnemonic.ElectrumV1Mnemonic`   |
     +--------------+------------------------------------------------------------------------+
     | Electrum-V2  |  :class:`hdwallet.mnemonics.electrum.v2.mnemonic.ElectrumV2Mnemonic`   |
@@ -55,10 +57,10 @@ class MNEMONICS:
     dictionary: Dict[str, Type[IMnemonic]] = {
         AlgorandMnemonic.name(): AlgorandMnemonic,
         BIP39Mnemonic.name(): BIP39Mnemonic,
+        SLIP39Mnemonic.name(): SLIP39Mnemonic,
         ElectrumV1Mnemonic.name(): ElectrumV1Mnemonic,
         ElectrumV2Mnemonic.name(): ElectrumV2Mnemonic,
         MoneroMnemonic.name(): MoneroMnemonic,
-        SLIP39Mnemonic.name(): SLIP39Mnemonic,
     }
 
     @classmethod
diff --git a/hdwallet/mnemonics/algorand/mnemonic.py b/hdwallet/mnemonics/algorand/mnemonic.py
@@ -8,14 +8,12 @@
     Union, Dict, List, Optional
 )
 
-import unicodedata
-
 from ...entropies import (
     IEntropy, AlgorandEntropy, ALGORAND_ENTROPY_STRENGTHS
 )
 from ...crypto import sha512_256
 from ...exceptions import (
-    Error, EntropyError, MnemonicError, ChecksumError
+    EntropyError, MnemonicError, ChecksumError
 )
 from ...utils import (
     get_bytes, bytes_to_string, convert_bits
diff --git a/hdwallet/mnemonics/electrum/v1/mnemonic.py b/hdwallet/mnemonics/electrum/v1/mnemonic.py
@@ -8,8 +8,6 @@
     Dict, List, Union, Optional
 )
 
-import unicodedata
-
 from ....entropies import (
     IEntropy, ElectrumV1Entropy, ELECTRUM_V1_ENTROPY_STRENGTHS
 )
diff --git a/hdwallet/mnemonics/electrum/v2/mnemonic.py b/hdwallet/mnemonics/electrum/v2/mnemonic.py
@@ -8,8 +8,6 @@
     Dict, List, Union, Optional
 )
 
-import unicodedata
-
 from ....entropies import (
     IEntropy, ElectrumV2Entropy, ELECTRUM_V2_ENTROPY_STRENGTHS
 )
diff --git a/hdwallet/mnemonics/imnemonic.py b/hdwallet/mnemonics/imnemonic.py
@@ -72,7 +72,7 @@ def mnemonic_type(self) -> str:
         :rtype: str
         """
 
-        raise NotImplemented
+        raise NotImplementedError
 
     def language(self) -> str:
         """
@@ -245,6 +245,6 @@ def normalize(cls, mnemonic: Union[str, List[str]]) -> List[str]:
         if isinstance(mnemonic, str):
             if ( len(mnemonic.strip()) * 4 in cls.words_to_entropy_strength.values()
                  and all(c in string.hexdigits for c in mnemonic.strip())):
-               mnemonic: str = cls.from_entropy(mnemonic, language="english")
+                mnemonic: str = cls.from_entropy(mnemonic, language="english")
             mnemonic: list = mnemonic.strip().split()
         return list(map(lambda _: unicodedata.normalize("NFKD", _.lower()), mnemonic))
diff --git a/hdwallet/mnemonics/monero/mnemonic.py b/hdwallet/mnemonics/monero/mnemonic.py
@@ -8,8 +8,6 @@
     Union, Dict, List
 )
 
-import unicodedata
-
 from ...entropies import (
     IEntropy, MoneroEntropy, MONERO_ENTROPY_STRENGTHS
 )
diff --git a/hdwallet/mnemonics/slip39/mnemonic.py b/hdwallet/mnemonics/slip39/mnemonic.py
@@ -6,14 +6,14 @@
 
 import re
 from typing import (
-    Union, Dict, Iterable, List, Optional, Tuple
+    Union, Dict, Iterable, List, Optional, Sequence, Tuple
 )
 
 from ...entropies import (
-    IEntropy, SLIP39Entropy, SLIP39_ENTROPY_STRENGTHS
+    ENTROPIES, IEntropy, SLIP39Entropy, SLIP39_ENTROPY_STRENGTHS
 )
 from ...exceptions import (
-    Error, EntropyError, MnemonicError, ChecksumError
+    EntropyError, MnemonicError
 )
 from ...utils import (
     get_bytes,
@@ -38,7 +38,7 @@ class SLIP39_MNEMONIC_LANGUAGES:
     ENGLISH: str = "english"
 
 
-def group_parser( group_spec, size_default: Optional[int]=None ) -> Tuple[str,Tuple[int,int]]:
+def group_parser( group_spec, size_default: Optional[int] = None) -> Tuple[str, Tuple[int, int]]:
     """Parse a SLIP-39 group specification; a name up to the first digit, ( or /, then a
     threshold/count spec:
 
@@ -79,7 +79,8 @@ def group_parser( group_spec, size_default: Optional[int]=None ) -> Tuple[str,Tu
     if size < 1 or require > size or ( require == 1 and size > 1 ):
         raise ValueError( f"Impossible group specification from {group_spec!r} w/ default size {size_default!r}: {name,(require,size)!r}" )
 
-    return name,(require,size)
+    return (name, (require, size))
+
 
 group_parser.REQUIRED_RATIO	= 1/2
 group_parser.RE			= re.compile( # noqa E305
@@ -106,7 +107,7 @@ def group_parser( group_spec, size_default: Optional[int]=None ) -> Tuple[str,Tu
     """, re.VERBOSE )
 
 
-def language_parser(language: str) -> Dict[Tuple[str,Tuple[int,int]],Dict[Union[str,int],Tuple[int,int]]]:
+def language_parser(language: str) -> Dict[Tuple[str, Tuple[int, int]], Dict[Union[str, int], Tuple[int, int]]]:
     """
     Parse a SLIP-39 language dialect specification.
 
@@ -140,28 +141,28 @@ def language_parser(language: str) -> Dict[Tuple[str,Tuple[int,int]],Dict[Union[
     if not s_match and language.strip():
         raise ValueError( f"Invalid SLIP-39 specification: {language!r}" )
 
-
     groups			= s_match and s_match.group("groups") or ""
     groups_list			= groups.strip().split(",")
     secret			= s_match and s_match.group("secret") or ""
     s_size_default		= len(groups_list) if groups_list else None
-    s_name,(s_thresh,s_size)	= group_parser(secret, size_default=s_size_default)
+    s_name, (s_thresh, s_size)	= group_parser(secret, size_default=s_size_default)
     groups_list		       += [''] * (s_size - len(groups_list))  # default any missing group specs
 
-    g_names,g_sizes		= [],[]
+    g_names, g_sizes		= [], []
     for group in groups_list:
         # Default size inferred from Fibonacci sequence of mnemonics required by default
         size_default		= None if len(g_sizes) < 2 else min(
             MAX_SHARE_COUNT,
             2 * ( g_sizes[-1][0] + g_sizes[-2][0] )
         )
-        g_name,g_dims		= group_parser(group, size_default=size_default)
+        g_name, g_dims		= group_parser(group, size_default=size_default)
         if not g_name:
             g_name		= len(g_sizes)
         g_names.append(g_name)
         g_sizes.append(g_dims)
 
-    return { (s_name.strip(),(s_thresh,s_size)): dict(zip(g_names,g_sizes)) }
+    return { (s_name.strip(), (s_thresh, s_size)): dict(zip(g_names, g_sizes)) }
+
 
 language_parser.REQUIRED_RATIO	= 1/2
 language_parser.RE		= re.compile(
@@ -233,11 +234,10 @@ class SLIP39Mnemonic(IMnemonic):
         SLIP39_MNEMONIC_LANGUAGES.ENGLISH: "slip39/wordlist/english.txt",
     }
 
-
     def __init__(self, mnemonic: Union[str, List[str]], **kwargs) -> None:
         super().__init__(mnemonic, **kwargs)
         # We know that normalize has already validated _mnemonic's length
-        self._words, = filter(lambda l: len(self._mnemonic) % l == 0, self.words_list)
+        self._words, = filter(lambda w: len(self._mnemonic) % w == 0, self.words_list)
 
     @classmethod
     def name(cls) -> str:
@@ -324,16 +324,14 @@ def from_entropy(cls, entropy: Union[str, bytes, IEntropy], language: str, **kwa
             "Invalid entropy instance", expected=[str, bytes,]+list(ENTROPIES.dictionary.values()), got=type(entropy)
         )
 
-
     @classmethod
     def is_valid_language(cls, language: str) -> bool:
         try:
             language_parser(language)
             return True
-        except Exception as exc:
+        except Exception:
             return False
 
-
     @classmethod
     def encode(
         cls,
@@ -373,20 +371,19 @@ def encode(
                 "Wrong entropy strength", expected=SLIP39Entropy.strengths, got=(len(entropy) * 8)
             )
 
-        ((s_name,(s_thresh,s_size)),groups), = language_parser(language).items()
+        ((s_name, (s_thresh, s_size)), groups), = language_parser(language).items()
         assert s_size == len(groups)
         group_mnemonics: Sequence[Sequence[str]] = generate_mnemonics(
-            group_threshold = s_thresh,
-            groups = groups.values(),
-            master_secret = entropy,
-            passphrase = passphrase.encode('UTF-8'),
-            extendable = extendable,
-            iteration_exponent = iteration_exponent,
+            group_threshold=s_thresh,
+            groups=groups.values(),
+            master_secret=entropy,
+            passphrase=passphrase.encode('UTF-8'),
+            extendable=extendable,
+            iteration_exponent=iteration_exponent,
         )
 
         return "\n".join(sum(group_mnemonics, []))
 
-
     @classmethod
     def decode(
         cls, mnemonic: str, passphrase: str = "",
@@ -432,8 +429,7 @@ def decode(
             entropy = bytes_to_string(recovery.recover(passphrase.encode('UTF-8')))
             return entropy
         except Exception as exc:
-            raise MnemonicError(f"Failed to recover SLIP-39 Mnemonics", detail=exc) from exc
-
+            raise MnemonicError("Failed to recover SLIP-39 Mnemonics", detail=exc) from exc
 
     NORMALIZE			= re.compile(
         r"""
@@ -450,7 +446,6 @@ def decode(
             $
         """, re.VERBOSE )
 
-
     @classmethod
     def normalize(cls, mnemonic: Union[str, List[str]]) -> List[str]:
         """Filter the supplied lines of mnemonics, rejecting groups of mnemonics not evenly divisible by
@@ -479,12 +474,12 @@ def normalize(cls, mnemonic: Union[str, List[str]]) -> List[str]:
         if isinstance( mnemonic, str ):
             mnemonic_list: List[str] = []
 
-            for line_no,m in enumerate( map( cls.NORMALIZE.match, mnemonic.split("\n"))):
+            for line_no, m in enumerate( map( cls.NORMALIZE.match, mnemonic.split("\n"))):
                 if not m:
                     errors.append( f"@L{line_no+1}; unrecognized mnemonic ignored" )
                     continue
 
-                pref,mnem	= m.groups()
+                pref, mnem	= m.groups()
                 if not mnem:  # Blank lines or lines without Mnemonic skipped
                     continue
                 mnem		= super().normalize(mnem)
@@ -495,12 +490,12 @@ def normalize(cls, mnemonic: Union[str, List[str]]) -> List[str]:
         else:
             mnemonic_list: List[str] = mnemonic
 
-        word_lengths = list(filter(lambda l: len(mnemonic_list) % l == 0, cls.words_list))
+        word_lengths = list(filter(lambda w: len(mnemonic_list) % w == 0, cls.words_list))
         if not word_lengths:
-            errors.append( f"Mnemonics not a multiple of valid length, or a single hex entropy value" )
+            errors.append( "Mnemonics not a multiple of valid length, or a single hex entropy value" )
         if errors:
             raise MnemonicError(
-                f"Invalid SLIP39 Mnemonics",
+                "Invalid SLIP39 Mnemonics",
                 expected=f"multiple of {', '.join(map(str, cls.words_list))}",
                 got=f"{len(mnemonic_list)} total words",
                 detail="; ".join(errors),
diff --git a/hdwallet/seeds/slip39.py b/hdwallet/seeds/slip39.py
@@ -8,8 +8,6 @@
     Optional, Union
 )
 
-import unicodedata
-
 from ..exceptions import EntropyError
 from ..mnemonics import IMnemonic
 from ..mnemonics.bip39 import BIP39Mnemonic
diff --git a/requirements/dev.txt b/requirements/dev.txt
@@ -1,3 +1,4 @@
 build
 setuptools
 wheel
+flake8
diff --git a/tests/cli/test_cli_seed.py b/tests/cli/test_cli_seed.py
@@ -80,7 +80,6 @@ def test_cli_seed(data, cli_tester):
                     cli = cli_tester.invoke(
                         cli_main, cli_args
                     )
-                    print( f"cli output: {cli.output}" )
                     output = json.loads(cli.output)
 
                     assert output["client"] == client
diff --git a/tests/data/raw/languages.txt b/tests/data/raw/languages.txt
@@ -19,6 +19,11 @@ Spanish
 Turkish
 
 
+SLIP39 Languages
+------------------
+English
+
+
 Electrum-V1 Languages
 -----------------------
 English
@@ -44,8 +49,3 @@ Japanese
 Portuguese
 Russian
 Spanish
-
-
-SLIP39 Languages
-------------------
-English

Original file line number	Diff line number	Diff line change
`@@ -8,14 +8,12 @@`
`8`	`8`	`Union, Dict, List, Optional`
`9`	`9`	`)`
`10`	`10`
`11`		`-import unicodedata`
`12`		`-`
`13`	`11`	`from ...entropies import (`
`14`	`12`	`IEntropy, AlgorandEntropy, ALGORAND_ENTROPY_STRENGTHS`
`15`	`13`	`)`
`16`	`14`	`from ...crypto import sha512_256`
`17`	`15`	`from ...exceptions import (`
`18`		`- Error, EntropyError, MnemonicError, ChecksumError`
	`16`	`+ EntropyError, MnemonicError, ChecksumError`
`19`	`17`	`)`
`20`	`18`	`from ...utils import (`
`21`	`19`	`get_bytes, bytes_to_string, convert_bits`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,6 @@`
`8`	`8`	`Dict, List, Union, Optional`
`9`	`9`	`)`
`10`	`10`
`11`		`-import unicodedata`
`12`		`-`
`13`	`11`	`from ....entropies import (`
`14`	`12`	`IEntropy, ElectrumV1Entropy, ELECTRUM_V1_ENTROPY_STRENGTHS`
`15`	`13`	`)`
Original file line number	Diff line number	Diff line change
`@@ -8,8 +8,6 @@`
`8`	`8`	`Union, Dict, List`
`9`	`9`	`)`
`10`	`10`
`11`		`-import unicodedata`
`12`		`-`
`13`	`11`	`from ...entropies import (`
`14`	`12`	`IEntropy, MoneroEntropy, MONERO_ENTROPY_STRENGTHS`
`15`	`13`	`)`