Ethereum Utils
Common utility functions for codebases which interact with ethereum.
Installation
pip install ethereum-utilsDocumentation
All functions can be imported directly from the eth_utils module
ABI Utils
event_abi_to_log_topic(event_abi) -> bytes
Returns the 32 byte log topic for the given event abi.
>>> event_abi_to_log_topic({'type': 'event', 'anonymous': False, 'name': 'MyEvent', 'inputs': []})
b'M\xbf\xb6\x8bC\xdd\xdf\xa1+Q\xeb\xe9\x9a\xb8\xfd\xedb\x0f\x9a\n\xc21B\x87\x9aO\x19*\x1byR\xd2'event_signature_to_log_topic(event_signature) -> bytes
Returns the 32 byte log topic for the given event signature.
>>> event_signature_to_log_topic('MyEvent()')
b'M\xbf\xb6\x8bC\xdd\xdf\xa1+Q\xeb\xe9\x9a\xb8\xfd\xedb\x0f\x9a\n\xc21B\x87\x9aO\x19*\x1byR\xd2'function_abi_to_4byte_selector(function_abi) -> bytes
Returns the 4 byte function selector for the given function abi.
>>> function_abi_to_4byte_selector({'type': 'function', 'name': 'myFunction', 'inputs': [], 'outputs': []})
b'\xc3x\n:'function_signature_to_4byte_selector(function_signature) -> bytes
Returns the 4 byte function selector for the given function signature.
>>> function_signature_to_4byte_selector('myFunction()')
b'\xc3x\n:'Address Utils
is_address(value) -> bool
Returns True if the value is one of the following accepted address formats.
- 20 byte hexidecimal, upper/lower/mixed case, with or without
0xprefix:'d3cda913deb6f67967b99d67acdfa1712c293601''0xd3cda913deb6f67967b99d67acdfa1712c293601''0xD3CDA913DEB6F67967B99D67ACDFA1712C293601''0xd3CdA913deB6f67967B99D67aCDFa1712C293601'
- 20 byte hexidecimal padded to 32 bytes with null bytes, upper/lower/mixed case, with or without
0xprefix:'000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601''000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601''0x000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601''0x000000000000000000000000D3CDA913DEB6F67967B99D67ACDFA1712C293601''0x000000000000000000000000d3CdA913deB6f67967B99D67aCDFa1712C293601'
- 20 text or bytes string:
'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01'
- 20 text or bytes string padded to 32 bytes with null bytes.
'\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01'
This function has two special cases when it will return False:
- a 20-byte hex string that has mixed case, with an invalid checksum
- a 32-byte value that is all null bytes
>>> is_address('d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
True
>>> is_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_address('0x000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_address('0x000000000000000000000000D3CDA913DEB6F67967B99D67ACDFA1712C293601')
True
>>> is_address('0x000000000000000000000000d3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
True
>>> is_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
True
>>> is_address('0x0000000000000000000000000000000000000000000000000000000000000000')
False
>>> is_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
Falseis_hex_address(value) => bool
Return True if the value is a 20 byte hexidecimal encoded string in any of
upper/lower/mixed casing, with or without the 0x prefix. Otherwise return
False
'd3cda913deb6f67967b99d67acdfa1712c293601''0xd3cda913deb6f67967b99d67acdfa1712c293601''0xD3CDA913DEB6F67967B99D67ACDFA1712C293601''0xd3CdA913deB6f67967B99D67aCDFa1712C293601'
>>> is_hex_address('d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_hex_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_hex_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
True
>>> is_hex_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_hex_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_hex_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_hex_address('0x000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_hex_address('0x000000000000000000000000D3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_hex_address('0x000000000000000000000000d3CdA913deB6f67967B99D67aCDFa1712C293601')
False
>>> is_hex_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
False
>>> is_hex_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
False
>>> is_hex_address('0x0000000000000000000000000000000000000000000000000000000000000000')
False
>>> is_hex_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
Falseis_binary_address(value) -> bool
Return True if the value is a 20 byte string.
>>> is_binary_address('d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_binary_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_binary_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_binary_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
False
>>> is_binary_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_binary_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_binary_address('0x000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_binary_address('0x000000000000000000000000D3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_binary_address('0x000000000000000000000000d3CdA913deB6f67967B99D67aCDFa1712C293601')
False
>>> is_binary_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
True
>>> is_binary_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
False
>>> is_binary_address('0x0000000000000000000000000000000000000000000000000000000000000000')
False
>>> is_binary_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
Falseis_32byte_address(value) -> bool
Return True if the value is a 20 byte address that has been padded to 32
bytes. This function allows both bytes or hexidecimal encoded strings.
Hexidecimal strings may optionally be 0x prefixed. The padding bytes
must be zeros.
Note: this method returns false for the zero address.
>>> is_32byte_address('d3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_32byte_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_32byte_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_32byte_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
False
>>> is_32byte_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_32byte_address('000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_32byte_address('0x000000000000000000000000d3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_32byte_address('0x000000000000000000000000D3CDA913DEB6F67967B99D67ACDFA1712C293601')
True
>>> is_32byte_address('0x000000000000000000000000d3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_32byte_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
False
>>> is_32byte_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01')
True
>>> is_32byte_address('0x0000000000000000000000000000000000000000000000000000000000000000')
False
>>> is_32byte_address('\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00\x00')
Falseis_canonical_address(value) -> bool
Returns True if the value is an address in it's canonical form.
The canonical representation of an address according to ethereum-utils is a
20 byte long string of bytes, eg:
b'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01'
>>> is_canonical_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_canonical_address(b'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd')
True
>>> is_canonical_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd')
Falseis_checksum_address(value) -> bool
Returns True if the value is a checksummed address as specified by
ERC55
>>> is_checksum_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_checksum_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_checksum_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_checksum_address('0x52908400098527886E0F7030069857D2E4169EE7')
True
>>> is_checksum_address('0xde709f2102306220921060314715629080e2fb77')
Trueis_checksum_formatted_address(value) -> bool
Returns True if the value is formatted as an
ERC55 checksum address.
>>> is_checksum_formatted_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_checksum_formatted_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
False
>>> is_checksum_formatted_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_checksum_formatted_address('0x52908400098527886E0F7030069857D2E4169EE7')
False
>>> is_checksum_formatted_address('0xde709f2102306220921060314715629080e2fb77')
Falseis_normalized_address(value) -> bool
Returns True if the value is an address in its normalized form.
The normalized representation of an address is the lowercased 20 byte hexidecimal format.
>>> is_normalized_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
False
>>> is_normalized_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
True
>>> is_normalized_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
False
>>> is_normalized_address('0x52908400098527886E0F7030069857D2E4169EE7')
False
>>> is_normalized_address('0xde709f2102306220921060314715629080e2fb77')
Trueis_same_address(a, b) -> bool
Returns True if both a and b are valid addresses according to the
is_address function and that they are both representations of the same
address.
>>> is_same_address('0xd3cda913deb6f67967b99d67acdfa1712c293601', '0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
True
>>> is_same_address('0xd3cda913deb6f67967b99d67acdfa1712c293601', '0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
True
>>> is_same_address('0xd3cda913deb6f67967b99d67acdfa1712c293601', '\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd')
Trueto_canonical_address(value) -> bytes
Given any valid representation of an address return it's canonical form.
>>> to_canonical_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
b'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd'
>>> to_canonical_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
b'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd'
>>> to_canonical_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
b'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd'
>>> to_canonical_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd')
b'\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd'to_checksum_address(value) -> text
Given any valid representation of an address return the checksummed representation.
>>> to_checksum_address('0xd3cda913deb6f67967b99d67acdfa1712c293601')
'0xd3CdA913deB6f67967B99D67aCDFa1712C293601'
>>> to_checksum_address('0xD3CDA913DEB6F67967B99D67ACDFA1712C293601')
'0xd3CdA913deB6f67967B99D67aCDFa1712C293601'
>>> to_checksum_address('0xd3CdA913deB6f67967B99D67aCDFa1712C293601')
'0xd3CdA913deB6f67967B99D67aCDFa1712C293601'
>>> to_checksum_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01xd')
'0xd3CdA913deB6f67967B99D67aCDFa1712C293601'to_normalized_address(value) -> text
Given any valid representation of an address return the normalized representation.
>>> to_normalized_address('\xd3\xcd\xa9\x13\xde\xb6\xf6yg\xb9\x9dg\xac\xdf\xa1q,)6\x01') # raw bytes
'0xd3cda913deb6f67967b99d67acdfa1712c293601'
>>> to_normalized_address(b'0xc6d9d2cd449a754c494264e1809c50e34d64562b') # hex encoded (as byte string)
'0xc6d9d2cd449a754c494264e1809c50e34d64562b'
>>> to_normalized_address('0xc6d9d2cd449a754c494264e1809c50e34d64562b') # hex encoded
'0xc6d9d2cd449a754c494264e1809c50e34d64562b'
>>> to_normalized_address('0XC6D9D2CD449A754C494264E1809C50E34D64562B') # cap-cased
'0xc6d9d2cd449a754c494264e1809c50e34d64562b'
>>> to_normalized_address('0x000000000000000000000000c305c901078781c232a2a521c2af7980f8385ee9') # padded to 32 bytes
'0xc305c901078781c232a2a521c2af7980f8385ee9',Crypto Utils
keccak(value) -> bytes
Given any string returns the sha3/keccak hash. If value is not a byte
string it will be converted using the force_bytes function.
>>> keccak('')
b"\xc5\xd2F\x01\x86\xf7#<\x92~}\xb2\xdc\xc7\x03\xc0\xe5\x00\xb6S\xca\x82';{\xfa\xd8\x04]\x85\xa4p"Currency Utils
denoms
Object with property access to all of the various denominations for ether. Available denominations are:
+--------------+---------------------------------+ | denomination | amount in wei | +--------------+---------------------------------+ | wei | 1 | | kwei | 1000 | | babbage | 1000 | | femtoether | 1000 | | mwei | 1000000 | | lovelace | 1000000 | | picoether | 1000000 | | gwei | 1000000000 | | shannon | 1000000000 | | nanoether | 1000000000 | | nano | 1000000000 | | szabo | 1000000000000 | | microether | 1000000000000 | | micro | 1000000000000 | | finney | 1000000000000000 | | milliether | 1000000000000000 | | milli | 1000000000000000 | | ether | 1000000000000000000 | | kether | 1000000000000000000000 | | grand | 1000000000000000000000 | | mether | 1000000000000000000000000 | | gether | 1000000000000000000000000000 | | tether | 1000000000000000000000000000000 | +--------------+---------------------------------+
>>> denoms.wei
1
>>> denoms.finney
1000000000000000
>>> denoms.ether
1000000000000000000Encoding Utils
big_endian_to_int(value) -> integer
Returns value converted to an integer (from a big endian representation).
>>> big_endian_to_int(b'\x00')
0
>>> big_endian_to_int(b'\x01')
1
>>> big_endian_to_int(b'\x01\x00')
256int_to_big_endian(value) -> bytes
Returns value converted to the big endian representation.
>>> int_to_big_endian(0)
b'\x00'
>>> int_to_big_endian(1)
b'\x01'
>>> int_to_big_endian(256)
b'\x01\x00'Formatting Utils
pad_left(value, to_size, pad_with) -> string
Returns value padded to the length specified by to_size with the string pad_with.
>>> pad_left('test', 6, '0')
'00test'
>>> pad_left('testing', 6, '0')
'testing'
>>> pad_left('test', 8, '123')
'12312test'pad_right(value, to_size, pad_with) -> string
Returns value padded to the length specified by to_size with the string pad_with.
>>> pad_right('test', 6, '0')
'test00'
>>> pad_right('testing', 6, '0')
'testing'
>>> pad_right('test', 8, '123')
'test12312'Functional Utils
compose(*callables) -> callable
DEPRECATED in 0.3.0.
Returns a single function which is the composition of the given callables.
>>> def f(v):
... return v * 3
...
>>> def g(v):
... return v + 2
...
>>> def h(v):
... return v % 5
...
>>> compose(f, g, h)(1)
0
>>> h(g(f(1)))
0
>>> compose(f, g, h)(2)
3
>>> h(g(f(1)))
3
>>> compose(f, g, h)(3)
1
>>> h(g(f(1)))
1
>>> compose(f, g, h)(4)
4
>>> h(g(f(1)))
4
flatten_return(callable) -> callable() -> tuple
Decorator which performs a non-recursive flattening of the return value from
the given callable.
>>> flatten_return(lambda: [[1, 2, 3], [4, 5], [6]])
(1, 2, 3, 4, 5, 6)sort_return(callable) => callable() -> tuple
Decorator which sorts the return value from the given callable.
>>> flatten_return(lambda: [[1, 2, 3], [4, 5], [6]])
(1, 2, 3, 4, 5, 6)reversed_return(callable) => callable() -> tuple
Decorator which reverses the return value from the given callable.
>>> reversed_return(lambda: [1, 5, 2, 4, 3])
(3, 4, 2, 5, 1)to_dict(callable) => callable() -> dict
Decorator which casts the return value from the given callable to a dictionary.
>>> @to_dict
... def build_thing():
... yield 'a', 1
... yield 'b', 2
... yield 'c', 3
...
>>> build_thing()
{'a': 1, 'b': 2, 'c': 3}to_list(callable) => callable() -> list
Decorator which casts the return value from the given callable to a list.
>>> @to_list
... def build_thing():
... yield 'a'
... yield 'b'
... yield 'c'
...
>>> build_thing()
['a', 'b', 'c']to_ordered_dict(callable) => callable() -> collections.OrderedDict
Decorator which casts the return value from the given callable to an ordered dictionary of type collections.OrderedDict.
>>> @to_ordered_dict
... def build_thing():
... yield 'd', 4
... yield 'a', 1
... yield 'b', 2
... yield 'c', 3
...
>>> build_thing()
OrderedDict([('d', 4), ('a', 1), ('b', 2), ('c', 3)])to_tuple(callable) => callable() -> tuple
Decorator which casts the return value from the given callable to a tuple.
>>> @to_tuple
... def build_thing():
... yield 'a'
... yield 'b'
... yield 'c'
...
>>> build_thing()
('a', 'b', 'c')to_set(callable) => callable() -> set
Decorator which casts the return value from the given callable to a set.
>>> @to_set
... def build_thing():
... yield 'a'
... yield 'b'
... yield 'a' # duplicate
... yield 'c'
...
>>> build_thing()
{'a', 'b', 'c'}apply_to_return_value(callable) => decorator_fn
This function takes a single callable and returns a decorator. The returned decorator, when applied to a function, will incercept the function's return value, pass it to the callable, and return the value returned by the callable.
>>> double = apply_to_return_value(lambda v: v * 2)
>>> @double
... def f(v):
... return v
...
>>> f(2)
4
>>> f(3)
6Hexidecimal Utils
add_0x_prefix(value) -> string
Returns value with a 0x prefix. If the value is already prefixed it is returned as-is.
>>> add_0x_prefix('12345')
'0x12345'
>>> add_0x_prefix('0x12345')
'0x12345'decode_hex(value) -> bytes
Returns value decoded into a byte string. Accepts any string with or without the 0x prefix.
>>> decode_hex('0x123456')
b'\x124V'
>>> decode_hex('123456')
b'\x124V'encode_hex(value) -> string
Returns value encoded into a hexidecimal representation with a 0x prefix
>>> encode_hex('\x01\x02\x03')
'0x010203'is_0x_prefixed(value) -> bool
Returns True if value has a 0x prefix.
>>> is_0x_prefixed('12345')
False
>>> is_0x_prefixed('0x12345')
True
>>> is_0x_prefixed(b'0x12345')
Trueis_hex(value) -> bool
Returns True if value is a valid hexidecimal encoded string of length >= 1.
>>> is_hex('')
False
>>> is_hex(b'')
False
>>> is_hex('0x')
False
>>> is_hex(b'0x')
False
>>> is_hex('0X')
False
>>> is_hex(b'0X')
False
>>> is_hex('1234567890abcdef')
True
>>> is_hex('0x1234567890abcdef')
True
>>> is_hex('0x1234567890ABCDEF')
True
>>> is_hex('0x1234567890AbCdEf')
True
>>> is_hex('12345') # odd length
False
>>> is_hex('123456__abcdef') # non hex characters
Falseremove_0x_prefix(value) -> string
Returns value with the 0x prefix stripped. If the value does not have a
0x prefix it is returned as-is.
>>> remove_0x_prefix('12345')
'12345'
>>> remove_0x_prefix('0x12345')
'12345'
>>> remove_0x_prefix(b'0x12345')
b'12345'String Utils
coerce_args_to_bytes(callable) -> callable
Decorator which will convert any string arguments both positional or keyword
into byte strings using the force_bytes function. This is a recursive
operation which will reach down into mappings and list-like objects as well.
>>> @coerce_args_to_bytes
... def do_thing(*args):
... return args
...
>>> do_thing('a', 1, b'a-byte-string', ['a', b'b', 1], {'a': 'a', 'b': ['x', b'y']})
(b'a', 1, b'a-byte-string', [b'a', b'b', 1], {'a': b'a', 'b': [b'x', b'y']})coerce_args_to_text(callable) -> callable
Decorator which will convert any string arguments both positional or keyword
into text strings using the force_text function. This is a recursive
operation which will reach down into mappings and list-like objects as well.
>>> @coerce_args_to_text
... def do_thing(*args):
... return args
...
>>> do_thing('a', 1, b'a-byte-string', ['a', b'b', 1], {'a': 'a', 'b': ['x', b'y']})
('a', 1, 'a-byte-string', ['a', 'b', 1], {'a': 'a', 'b': ['x', 'y']})coerce_return_to_bytes(callable) -> callable
Decorator which will convert any string return values into byte strings using
the force_text function. This is a recursive operation which will reach down
into mappings and list-like objects as well.
>>> @coerce_return_to_bytes
... def do_thing(*args):
... return args
...
>>> do_thing('a', 1, b'a-byte-string', ['a', b'b', 1], {'a': 'a', 'b': ['x', b'y']})
(b'a', 1, b'a-byte-string', [b'a', b'b', 1], {'a': b'a', 'b': [b'x', b'y']})coerce_return_to_text(callable) -> callable
Decorator which will convert any string return values into text strings using
the force_text function. This is a recursive operation which will reach down
into mappings and list-like objects as well.
>>> @coerce_return_to_bytes
... def do_thing(*args):
... return args
...
>>> do_thing('a', 1, b'a-byte-string', ['a', b'b', 1], {'a': 'a', 'b': ['x', b'y']})
('a', 1, 'a-byte-string', ['a', 'b', 1], {'a': 'a', 'b': ['x', 'y']})force_bytes(value, encoding='iso-8859-1') -> text
Returns value encoded into a byte string using the provided encoding. By
default this uses iso-8859-1 as it can handle all byte values between 0-255
(unlike utf8)
>>> force_bytes('abcd')
b'abcd'
>>> force_bytes(b'abcd')
b'abcd'force_obj_to_bytes(value) -> value
Returns value with all string elements converted to byte strings by
recursivly traversing mappings and list-like elements.
>>> force_obj_to_bytes(('a', 1, b'a-byte-string', ['a', b'b', 1], {'a': 'a', 'b': ['x', b'y']}))
(b'a', 1, b'a-byte-string', [b'a', b'b', 1], {'a': b'a', 'b': [b'x', b'y']})force_obj_to_text(value) -> value
Returns value with all string elements converted to text strings by
recursivly traversing mappings and list-like elements.
>>> force_obj_to_text(('a', 1, b'a-byte-string', ['a', b'b', 1], {'a': 'a', 'b': ['x', b'y']}))
('a', 1, 'a-byte-string', ['a', 'b', 1], {'a': 'a', 'b': ['x', 'y']})force_text(value, encoding='iso-8859-1') -> text
Returns value decoded into a text string using the provided encoding. By
default this uses iso-8859-1 as it can handle all byte values between 0-255
(unlike utf8)
>>> force_text(b'abcd')
'abcd'
>>> force_text('abcd')
'abcd'Type Utils
is_boolean(value) -> bool
Returns True if value is of type bool
>>> is_boolean(True)
True
>>> is_boolean(False)
False
>>> is_boolean(1)
Falseis_bytes(value) -> bool
Returns True if value is a byte string or a byte array.
>>> is_bytes('abcd')
False
>>> is_bytes(b'abcd')
True
>>> is_bytes(bytearray((1, 2, 3)))
Trueis_dict(value) -> bool
Returns True if value is a mapping type.
>>> is_dict({'a': 1})
True
>>> is_dict([1, 2, 3])
Falseis_integer(value) -> bool
Returns True if value is an integer
>>> is_integer(0)
True
>>> is_integer(1)
True
>>> is_integer('1')
False
>>> is_integer(1.1)
Falseis_list_like(value) -> bool
Returns True if value is a non-string sequence such as a sequence (such as a list or tuple).
>>> is_list_like('abcd')
False
>>> is_list_like([])
True
>>> is_list_like(tuple())
Trueis_list(value) -> bool
Returns True if value is a non-string sequence such as a list.
>>> is_list('abcd')
False
>>> is_list([])
True
>>> is_list(tuple())
Falseis_tuple(value) -> bool
Returns True if value is a non-string sequence such as a tuple.
>>> is_tuple('abcd')
False
>>> is_tuple([])
False
>>> is_tuple(tuple())
Trueis_null(value) -> bool
Returns True if value is None
>>> is_null(None)
True
>>> is_null(False)
Falseis_number(value) -> bool
Returns True if value is numeric
>>> is_number(1)
True
>>> is_number(1.1)
True
>>> is_number('1')
False
>>> is_number(decimal.Decimal('1'))
Trueis_string(value) -> bool
Returns True if value is of any string type.
>>> is_string('abcd')
True
>>> is_string(b'abcd')
True
>>> is_string(bytearray((1, 2, 3)))
Trueis_text(value) -> bool
Returns True if value is a text string.
>>> is_text(u'abcd')
True
>>> is_text(b'abcd')
False
>>> is_text(bytearray((1, 2, 3)))
False