Add __all__ to all modules

Be explicit about what we're exporting everywhere.

 [ yapified by gitreformat (github/ghtdak) on Mon Nov 30 21:11:30 2015 ]

Author: petertodd

README

@@ -69,6 +69,14 @@ accomodate this. In addition see b2x() and b2lx() for conversion from bytes to
 big/little-endian hex.
 
 
+Module import style
+-------------------
+
+While not always good style, it's often convenient for quick scripts if import
+* can be used. To support that all the modules have __all__ defined
+appropriately.
+
+
 Example Code
 ------------
 

bitcoin/base58.py

@@ -154,3 +154,12 @@ def __str__(self):
 
     def __repr__(self):
         return '%s(%r)' % (self.__class__.__name__, str(self))
+
+
+__all__ = ('B58_DIGITS',
+           'Base58Error',
+           'InvalidBase58Error',
+           'encode',
+           'decode',
+           'Base58ChecksumError',
+           'CBase58Data',)

bitcoin/bloom.py

@@ -193,3 +193,6 @@ def stream_serialize(self, f):
             bitcoin.core.serialize.BytesSerializer.stream_serialize(
                 bytes(self.vData), f)
         f.write(self.__struct.pack(self.nHashFuncs, self.nTweak, self.nFlags))
+
+
+__all__ = ('MurmurHash3', 'CBloomFilter',)

bitcoin/core/__init__.py

@@ -9,7 +9,7 @@
 # propagated, or distributed except according to the terms contained in the
 # LICENSE file.
 
-from __future__ import absolute_import, division, print_function, unicode_literals
+from __future__ import absolute_import, division, print_function
 
 import binascii
 import hashlib
@@ -805,3 +805,41 @@ def CheckBlock(block, fCheckPoW=True, fCheckMerkleRoot=True, cur_time=None):
     # Check merkle root
     if fCheckMerkleRoot and block.hashMerkleRoot != block.calc_merkle_root():
         raise CheckBlockError("CheckBlock() : hashMerkleRoot mismatch")
+
+
+__all__ = ('Hash',
+           'Hash160',
+           'COIN',
+           'MAX_MONEY',
+           'MAX_BLOCK_SIZE',
+           'MAX_BLOCK_SIGOPS',
+           'MoneyRange',
+           'x',
+           'b2x',
+           'lx',
+           'b2lx',
+           'str_money_value',
+           'ValidationError',
+           'COutPoint',
+           'CMutableOutPoint',
+           'CTxIn',
+           'CMutableTxIn',
+           'CTxOut',
+           'CMutableTxOut',
+           'CTransaction',
+           'CMutableTransaction',
+           'CBlockHeader',
+           'CBlock',
+           'CoreChainParams',
+           'CoreMainParams',
+           'CoreTestNetParams',
+           'CoreRegTestParams',
+           'CheckTransactionError',
+           'CheckTransaction',
+           'CheckBlockHeaderError',
+           'CheckProofOfWorkError',
+           'CheckProofOfWork',
+           'CheckBlockHeader',
+           'CheckBlockError',
+           'GetLegacySigOpCount',
+           'CheckBlock',)

bitcoin/core/key.py

@@ -176,3 +176,6 @@ def __repr__(self):
         else:
             return '%s(b%s)' % (self.__class__.__name__, super(CPubKey,
                                                                self).__repr__())
+
+
+__all__ = ('CECKey', 'CPubKey',)

bitcoin/core/script.py

@@ -14,7 +14,7 @@
 is in bitcoin.core.scripteval
 """
 
-from __future__ import absolute_import, division, print_function, unicode_literals
+from __future__ import absolute_import, division, print_function
 
 import sys
 _bchr = chr
@@ -879,3 +879,146 @@ def SignatureHash(script, txTo, inIdx, hashtype):
     if err is not None:
         raise ValueError(err)
     return h
+
+
+__all__ = ('MAX_SCRIPT_SIZE',
+           'MAX_SCRIPT_ELEMENT_SIZE',
+           'MAX_SCRIPT_OPCODES',
+           'OPCODE_NAMES',
+           'CScriptOp',
+
+           # every opcode
+           'OP_0',
+           'OP_FALSE',
+           'OP_PUSHDATA1',
+           'OP_PUSHDATA2',
+           'OP_PUSHDATA4',
+           'OP_1NEGATE',
+           'OP_RESERVED',
+           'OP_1',
+           'OP_TRUE',
+           'OP_2',
+           'OP_3',
+           'OP_4',
+           'OP_5',
+           'OP_6',
+           'OP_7',
+           'OP_8',
+           'OP_9',
+           'OP_10',
+           'OP_11',
+           'OP_12',
+           'OP_13',
+           'OP_14',
+           'OP_15',
+           'OP_16',
+           'OP_NOP',
+           'OP_VER',
+           'OP_IF',
+           'OP_NOTIF',
+           'OP_VERIF',
+           'OP_VERNOTIF',
+           'OP_ELSE',
+           'OP_ENDIF',
+           'OP_VERIFY',
+           'OP_RETURN',
+           'OP_TOALTSTACK',
+           'OP_FROMALTSTACK',
+           'OP_2DROP',
+           'OP_2DUP',
+           'OP_3DUP',
+           'OP_2OVER',
+           'OP_2ROT',
+           'OP_2SWAP',
+           'OP_IFDUP',
+           'OP_DEPTH',
+           'OP_DROP',
+           'OP_DUP',
+           'OP_NIP',
+           'OP_OVER',
+           'OP_PICK',
+           'OP_ROLL',
+           'OP_ROT',
+           'OP_SWAP',
+           'OP_TUCK',
+           'OP_CAT',
+           'OP_SUBSTR',
+           'OP_LEFT',
+           'OP_RIGHT',
+           'OP_SIZE',
+           'OP_INVERT',
+           'OP_AND',
+           'OP_OR',
+           'OP_XOR',
+           'OP_EQUAL',
+           'OP_EQUALVERIFY',
+           'OP_RESERVED1',
+           'OP_RESERVED2',
+           'OP_1ADD',
+           'OP_1SUB',
+           'OP_2MUL',
+           'OP_2DIV',
+           'OP_NEGATE',
+           'OP_ABS',
+           'OP_NOT',
+           'OP_0NOTEQUAL',
+           'OP_ADD',
+           'OP_SUB',
+           'OP_MUL',
+           'OP_DIV',
+           'OP_MOD',
+           'OP_LSHIFT',
+           'OP_RSHIFT',
+           'OP_BOOLAND',
+           'OP_BOOLOR',
+           'OP_NUMEQUAL',
+           'OP_NUMEQUALVERIFY',
+           'OP_NUMNOTEQUAL',
+           'OP_LESSTHAN',
+           'OP_GREATERTHAN',
+           'OP_LESSTHANOREQUAL',
+           'OP_GREATERTHANOREQUAL',
+           'OP_MIN',
+           'OP_MAX',
+           'OP_WITHIN',
+           'OP_RIPEMD160',
+           'OP_SHA1',
+           'OP_SHA256',
+           'OP_HASH160',
+           'OP_HASH256',
+           'OP_CODESEPARATOR',
+           'OP_CHECKSIG',
+           'OP_CHECKSIGVERIFY',
+           'OP_CHECKMULTISIG',
+           'OP_CHECKMULTISIGVERIFY',
+           'OP_NOP1',
+           'OP_NOP2',
+           'OP_NOP3',
+           'OP_NOP4',
+           'OP_NOP5',
+           'OP_NOP6',
+           'OP_NOP7',
+           'OP_NOP8',
+           'OP_NOP9',
+           'OP_NOP10',
+           'OP_SMALLINTEGER',
+           'OP_PUBKEYS',
+           'OP_PUBKEYHASH',
+           'OP_PUBKEY',
+           'OP_INVALIDOPCODE',
+           'OPCODES_BY_NAME',
+           'DISABLED_OPCODES',
+           'CScriptInvalidError',
+           'CScriptTruncatedPushDataError',
+           'CScript',
+           'SCRIPT_VERIFY_P2SH',
+           'SCRIPT_VERIFY_STRICTENC',
+           'SCRIPT_VERIFY_EVEN_S',
+           'SCRIPT_VERIFY_NOCACHE',
+           'SIGHASH_ALL',
+           'SIGHASH_NONE',
+           'SIGHASH_SINGLE',
+           'SIGHASH_ANYONECANPAY',
+           'FindAndDelete',
+           'RawSignatureHash',
+           'SignatureHash',)

bitcoin/core/serialize.py

@@ -24,11 +24,11 @@
 if sys.version > '3':
     _bchr = lambda x: bytes([x])
     _bord = lambda x: x[0]
-    from io import BytesIO
+    from io import BytesIO as _BytesIO
 else:
     _bchr = chr
     _bord = ord
-    from cStringIO import StringIO as BytesIO
+    from cStringIO import StringIO as _BytesIO
 
 MAX_SIZE = 0x02000000
 
@@ -102,7 +102,7 @@ def stream_deserialize(cls, f):
 
     def serialize(self):
         """Serialize, returning bytes"""
-        f = BytesIO()
+        f = _BytesIO()
         self.stream_serialize(f)
         return f.getvalue()
 
@@ -115,7 +115,7 @@ def deserialize(cls, buf, allow_padding=False):
         If allow_padding is False and not all bytes are consumed during
         deserialization DeserializationExtraDataError will be raised.
         """
-        fd = BytesIO(buf)
+        fd = _BytesIO(buf)
         r = cls.stream_deserialize(fd)
         if not allow_padding:
             padding = fd.read()
@@ -186,13 +186,13 @@ def stream_deserialize(cls, f):
 
     @classmethod
     def serialize(cls, obj):
-        f = BytesIO()
+        f = _BytesIO()
         cls.stream_serialize(obj, f)
         return f.getvalue()
 
     @classmethod
     def deserialize(cls, buf):
-        return cls.stream_deserialize(BytesIO(buf))
+        return cls.stream_deserialize(_BytesIO(buf))
 
 
 class VarIntSerializer(Serializer):
@@ -332,3 +332,24 @@ def uint256_from_compact(c):
 def uint256_to_shortstr(u):
     s = "%064x" % (u,)
     return s[:16]
+
+
+__all__ = ('MAX_SIZE',
+           'Hash',
+           'Hash160',
+           'SerializationError',
+           'SerializationTruncationError',
+           'DeserializationExtraDataError',
+           'ser_read',
+           'Serializable',
+           'ImmutableSerializable',
+           'Serializer',
+           'VarIntSerializer',
+           'BytesSerializer',
+           'VectorSerializer',
+           'uint256VectorSerializer',
+           'intVectorSerialzer',
+           'VarStringSerializer',
+           'uint256_from_str',
+           'uint256_from_compact',
+           'uint256_to_shortstr',)

bitcoin/messages.py

@@ -11,15 +11,22 @@
 
 from __future__ import absolute_import, division, print_function, unicode_literals
 
+import hashlib
+import random
 import struct
 import time
-import random
+
+# Py3 compatibility
 import sys
 
 if sys.version > '3':
-    import io
+    _bchr = lambda x: bytes([x])
+    _bord = lambda x: x[0]
+    from io import BytesIO as _BytesIO
 else:
-    import cStringIO as io
+    _bchr = chr
+    _bord = ord
+    from cStringIO import StringIO as _BytesIO
 
 # Bad practice, so we have a __all__ at the end; this should be cleaned up
 # later.
@@ -46,7 +53,7 @@ def msg_deser(cls, f, protover=PROTO_VERSION):
         raise NotImplementedError
 
     def to_bytes(self, params=MainParams()):
-        f = BytesIO()
+        f = _BytesIO()
         self.msg_ser(f)
         body = f.getvalue()
         res = params.MESSAGE_START
@@ -64,7 +71,7 @@ def to_bytes(self, params=MainParams()):
 
     @classmethod
     def from_bytes(cls, b, protover=PROTO_VERSION):
-        f = BytesIO(b)
+        f = _BytesIO(b)
         return MsgSerializable.stream_deserialize(f, protover=protover)
 
     @classmethod
@@ -94,7 +101,7 @@ def stream_deserialize(cls, f, params=MainParams(), protover=PROTO_VERSION):
         if command in messagemap:
             cls = messagemap[command]
             #        print("Going to deserialize '%s'" % msg)
-            return cls.msg_deser(BytesIO(msg))
+            return cls.msg_deser(_BytesIO(msg))
         else:
             print("Command '%s' not in messagemap" % str(command, 'ascii'))
             return None

bitcoin/rpc.py

@@ -485,3 +485,6 @@ def addnodeonetry(self, node):
 
     def removenode(self, node):
         return self._addnode(node, 'remove')
+
+
+__all__ = ('JSONRPCException', 'RawProxy', 'Proxy',)

bitcoin/tests/test_scripteval.py

@@ -15,6 +15,10 @@
 import os
 import unittest
 
+import sys
+if sys.version > '3':
+    long = int
+
 from binascii import unhexlify
 
 from bitcoin.core import ValidationError