add type declarations, checks, fixes for bugs revealed by mypy

Author: dgpv

bitcointx/__init__.py

@@ -17,7 +17,7 @@
 from abc import ABCMeta
 from contextlib import contextmanager
 from collections import OrderedDict
-from typing import Tuple, Optional
+from typing import Dict, List, Tuple, Optional, Type
 
 import bitcointx.core
 import bitcointx.core.script
@@ -39,8 +39,8 @@ class ChainParamsMeta(ABCMeta):
         ('WALLET_DISPATCHER', issubclass,
          bitcointx.wallet.WalletCoinClassDispatcher),
     )
-    _registered_classes = OrderedDict()
-    _common_base_cls = None
+    _registered_classes: Dict[str, 'ChainParamsBase'] = OrderedDict()
+    _common_base_cls: Optional['ChainParamsBase'] = None
 
     def __new__(cls, cls_name, bases, dct, name=None):
         """check that the chainparams class uses unique base class
@@ -94,12 +94,12 @@ def __new__(cls, cls_name, bases, dct, name=None):
         return cls_instance
 
 
-def find_chain_params(*, name=None):
+def find_chain_params(*, name=None) -> Optional['ChainParamsBase']:
     return ChainParamsMeta._registered_classes.get(name)
 
 
-def get_registered_chain_params():
-    result = []
+def get_registered_chain_params() -> List['ChainParamsBase']:
+    result: List[ChainParamsBase] = []
     for param_cls in ChainParamsMeta._registered_classes.values():
         if param_cls not in result:
             result.append(param_cls)
@@ -110,7 +110,11 @@ def get_registered_chain_params():
 class ChainParamsBase(metaclass=ChainParamsMeta):
     """All chain param classes must be a subclass of this class."""
 
-    def get_confdir_path(self):
+    NAME: str
+    RPC_PORT: int
+    WALLET_DISPATCHER: Type[bitcointx.wallet.WalletCoinClassDispatcher]
+
+    def get_confdir_path(self) -> str:
         """Return default location for config directory"""
         name = self.NAME.split('/')[0]
 
@@ -122,12 +126,12 @@ def get_confdir_path(self):
 
         return os.path.expanduser('~/.{}'.format(name))
 
-    def get_config_path(self):
+    def get_config_path(self) -> str:
         """Return default location for config file"""
         name = self.NAME.split('/')[0]
         return '{}/{}.conf'.format(self.get_confdir_path(), name)
 
-    def get_datadir_extra_name(self):
+    def get_datadir_extra_name(self) -> str:
         """Return appropriate dir name to find data for the chain,
         and .cookie file. For mainnet, it will be an empty string -
         because data directory is the same as config directory.
@@ -138,11 +142,11 @@ def get_datadir_extra_name(self):
         return name_parts[1]
 
     @property
-    def name(self):
+    def name(self) -> str:
         return self.NAME
 
     @property
-    def readable_name(self):
+    def readable_name(self) -> str:
         name_parts = self.NAME.split('/')
         name_parts[0] = name_parts[0].capitalize()
         return ' '.join(name_parts)
@@ -205,6 +209,7 @@ def select_chain_params(params, **kwargs) -> PrevAndNewParams:
         params_cls = find_chain_params(name=params)
         if params_cls is None:
             raise ValueError('Unknown chain %r' % params)
+        assert isinstance(params_cls, type)
         params = params_cls(**kwargs)
     elif isinstance(params, type):
         params = params(**kwargs)

bitcointx/base58.py

@@ -16,7 +16,6 @@
 """Base58 encoding and decoding"""
 
 import binascii
-
 import bitcointx.core
 
 B58_DIGITS = '123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz'
@@ -41,7 +40,7 @@ class InvalidBase58Error(Base58Error):
     pass
 
 
-def encode(b):
+def encode(b: bytes) -> str:
     """Encode bytes to a base58-encoded string"""
 
     # Convert big-endian bytes to integer
@@ -52,7 +51,7 @@ def encode(b):
     while n > 0:
         n, r = divmod(n, 58)
         res.append(B58_DIGITS[r])
-    res = ''.join(res[::-1])
+    res_str = ''.join(res[::-1])
 
     # Encode leading zeros as base58 zeros
     czero = 0
@@ -62,10 +61,10 @@ def encode(b):
             pad += 1
         else:
             break
-    return B58_DIGITS[0] * pad + res
+    return B58_DIGITS[0] * pad + res_str
 
 
-def decode(s):
+def decode(s: str) -> bytes:
     """Decode a base58-encoding string, returning bytes"""
     if not s:
         return b''
@@ -110,7 +109,7 @@ class CBase58Data(bytes):
 
     base58_prefix = b''
 
-    def __new__(cls, s):
+    def __new__(cls, s) -> 'CBase58Data':
         k = decode(s)
         if len(k) < 4:
             raise Base58Error('data too short')
@@ -128,7 +127,7 @@ def __init__(self, s):
         __init__() with None in place of the string.
         """
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Convert to string"""
         check = bitcointx.core.Hash(self.base58_prefix + self)[0:4]
         return encode(self.base58_prefix + self + check)
@@ -168,21 +167,23 @@ def base58_match_prefix(cls, data):
             'base58 prefix does not match any known base58 address class')
 
     @classmethod
-    def from_bytes(cls, data):
+    def from_bytes(cls, data: bytes):
         """Instantiate from data"""
-        self = bytes.__new__(cls, data)
+        # mypy cannot handle arguments to `bytes.__new__()` at the moment,
+        # issue: https://github.com/python/typeshed/issues/2630
+        self = bytes.__new__(cls, data)  # type: ignore
         self.__init__(None)
         return self
 
-    def to_bytes(self):
+    def to_bytes(self) -> bytes:
         """Convert to bytes instance
 
         Note that it's the data represented that is converted;
         the prefix is not included.
         """
         return b'' + self
 
-    def __repr__(self):
+    def __repr__(self) -> str:
         return '%s(%r)' % (self.__class__.__name__, str(self))
 
 

bitcointx/bech32.py

@@ -29,15 +29,16 @@ class CBech32Data(bytes):
 
     Includes a witver and checksum.
     """
-    bech32_hrp = None
+    bech32_hrp: str
 
-    def __new__(cls, s):
+    def __new__(cls, s: str):
         """from bech32 addr to """
         if cls.bech32_hrp is None:
             raise TypeError(
                 'CBech32Data subclasses should define bech32_hrp attribute')
         witver, data = decode(cls.bech32_hrp, s)
-        if witver is None and data is None:
+        if witver is None or data is None:
+            assert witver is None and data is None
             raise Bech32Error('Bech32 decoding error')
 
         return cls.from_bytes(data, witver=witver)
@@ -50,30 +51,39 @@ def __init__(self, s):
         __init__() with None in place of the string.
         """
 
+    witver: int
+
     @classmethod
-    def from_bytes(cls, witprog, witver=None):
+    def from_bytes(cls, witprog: bytes, witver=None):
         """Instantiate from witver and data"""
         if witver is None or not (0 <= witver <= 16):
             raise ValueError(
                 'witver must be in range 0 to 16 inclusive; got %r' % witver)
-        self = bytes.__new__(cls, witprog)
+        # mypy cannot handle arguments to `bytes.__new__()` at the moment,
+        # issue: https://github.com/python/typeshed/issues/2630
+        self = bytes.__new__(cls, witprog)  # type: ignore
         self.witver = witver
 
         return self
 
-    def to_bytes(self):
+    def to_bytes(self) -> bytes:
         """Convert to bytes instance
 
         Note that it's the data represented that is converted; the checkum and
         witver is not included.
         """
         return b'' + self
 
-    def __str__(self):
+    def __str__(self) -> str:
         """Convert to string"""
-        return encode(self.__class__.bech32_hrp, self.witver, self)
-
-    def __repr__(self):
+        result = encode(self.__class__.bech32_hrp, self.witver, self)
+        if result is None:
+            raise AssertionError(
+                'encode should not fail, this is data that '
+                'was successfully decoded earlier')
+        return result
+
+    def __repr__(self) -> str:
         return '%s(%r)' % (self.__class__.__name__, str(self))