def generate_cache_key(value):
"""
Generates a cache key for the *args and **kwargs
"""
if is_bytes(value):
return hashlib.md5(value).hexdigest()
elif is_text(value):
return generate_cache_key(force_bytes(value))
elif is_boolean(value) or is_null(value) or is_number(value):
return generate_cache_key(repr(value))
elif is_dict(value):
return generate_cache_key((
(key, value[key])
for key
in sorted(value.keys())
))
elif is_list_like(value) or isinstance(value, Generator):
return generate_cache_key("".join((
generate_cache_key(item)
for item
in value
)))
else:
raise TypeError("Cannot generate cache key for value {0} of type {1}".format(
value,
type(value),
))
def generate_cache_key(value):
"""
Generates a cache key for the *args and **kwargs
"""
if is_bytes(value):
return hashlib.md5(value).hexdigest()
elif is_text(value):
return generate_cache_key(force_bytes(value))
elif is_boolean(value) or is_null(value) or is_number(value):
return generate_cache_key(repr(value))
elif is_dict(value):
return generate_cache_key((
(key, value[key])
for key
in sorted(value.keys())
))
elif is_list_like(value) or isinstance(value, Generator):
return generate_cache_key("".join((
generate_cache_key(item)
for item
in value
)))
else:
raise TypeError("Cannot generate cache key for value {0} of type {1}".format(
value,
type(value),
))
def is_primitive_type(value):
return any((
value is None,
is_boolean(value),
is_string(value),
is_number(value),
))
def test_encode_signed_real(base_integer_value,
value_bit_size,
high_bit_size,
low_bit_size,
data_byte_size):
if value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
SignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
elif high_bit_size + low_bit_size != value_bit_size:
with pytest.raises(ValueError):
SignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = SignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
if not is_number(base_integer_value):
with pytest.raises(EncodingTypeError) as exception_info:
encoder(base_integer_value)
assert 'SignedReal' in str(exception_info.value)
return
unsigned_integer_value = base_integer_value % 2**(high_bit_size + low_bit_size)
with decimal.localcontext(abi_decimal_context):
real_value = decimal.Decimal(unsigned_integer_value) / 2 ** low_bit_size
lower_bound, upper_bound = compute_signed_real_bounds(
high_bit_size,
low_bit_size,
)
if real_value < lower_bound or real_value > upper_bound:
with pytest.raises(ValueOutOfBounds):
encoder(real_value)
return
expected_value = zpad(int_to_big_endian(unsigned_integer_value), data_byte_size)
encoded_value = encoder(real_value)
assert encoded_value == expected_value
def test_encode_signed_fixed(value, value_bit_size, frac_places,
data_byte_size):
if value_bit_size > data_byte_size * 8:
pattern = r'Value byte size exceeds data size'
with pytest.raises(ValueError, match=pattern):
SignedFixedEncoder(
value_bit_size=value_bit_size,
frac_places=frac_places,
data_byte_size=data_byte_size,
)
return
encoder = SignedFixedEncoder(
value_bit_size=value_bit_size,
frac_places=frac_places,
data_byte_size=data_byte_size,
)
if not is_number(value):
pattern = r'Value of type .*NoneType.* cannot be encoded by SignedFixedEncoder'
with pytest.raises(EncodingTypeError, match=pattern):
encoder(value)
return
if SignedFixedEncoder.illegal_value_fn(value):
pattern = r'Value .*(NaN|Infinity|-Infinity).* cannot be encoded by SignedFixedEncoder'
with pytest.raises(IllegalValue, match=pattern):
encoder(value)
return
lower, upper = compute_signed_fixed_bounds(value_bit_size, frac_places)
if value < lower or value > upper:
pattern = r'Value .* cannot be encoded in .* bits'
with pytest.raises(ValueOutOfBounds, match=pattern):
encoder(value)
return
with decimal.localcontext(abi_decimal_context):
residue = value % (TEN**-frac_places)
if residue > 0:
pattern = re.escape(
'SignedFixedEncoder cannot encode value {}: '
'residue {} outside allowed fractional precision of {}'.format(
repr(value),
repr(residue),
frac_places,
))
with pytest.raises(IllegalValue, match=pattern):
encoder(value)
return
# Ensure no exception
encoder(value)
def test_encode_unsigned_fixed(value,
value_bit_size,
frac_places,
data_byte_size):
if value_bit_size > data_byte_size * 8:
pattern = r'Value byte size exceeds data size'
with pytest.raises(ValueError, match=pattern):
UnsignedFixedEncoder(
value_bit_size=value_bit_size,
frac_places=frac_places,
data_byte_size=data_byte_size,
)
return
encoder = UnsignedFixedEncoder(
value_bit_size=value_bit_size,
frac_places=frac_places,
data_byte_size=data_byte_size,
)
if not is_number(value):
pattern = r'Value `None` of type .*NoneType.* cannot be encoded by UnsignedFixedEncoder'
with pytest.raises(EncodingTypeError, match=pattern):
encoder(value)
return
if UnsignedFixedEncoder.illegal_value_fn(value):
pattern = r'Value .*(NaN|Infinity|-Infinity).* cannot be encoded by UnsignedFixedEncoder'
with pytest.raises(IllegalValue, match=pattern):
encoder(value)
return
lower, upper = compute_unsigned_fixed_bounds(value_bit_size, frac_places)
if value < lower or value > upper:
pattern = (
r'Value .* cannot be encoded by UnsignedFixedEncoder: '
r'Cannot be encoded in .* bits'
)
with pytest.raises(ValueOutOfBounds, match=pattern):
encoder(value)
return
with decimal.localcontext(abi_decimal_context):
residue = value % (TEN ** -frac_places)
if residue > 0:
pattern = r'Value .* cannot be encoded by UnsignedFixedEncoder: residue .* outside allowed'
with pytest.raises(IllegalValue, match=pattern):
encoder(value)
return
# Ensure no exception
encoder(value)
def test_encode_unsigned_real(base_integer_value, value_bit_size,
high_bit_size, low_bit_size, data_byte_size):
if value_bit_size > data_byte_size * 8:
with pytest.raises(ValueError):
UnsignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
elif high_bit_size + low_bit_size != value_bit_size:
with pytest.raises(ValueError):
UnsignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
return
encoder = UnsignedRealEncoder.as_encoder(
value_bit_size=value_bit_size,
high_bit_size=high_bit_size,
low_bit_size=low_bit_size,
data_byte_size=data_byte_size,
)
if not is_number(base_integer_value):
with pytest.raises(EncodingTypeError):
encoder(base_integer_value)
return
real_value = decimal.Decimal(base_integer_value) / 2**low_bit_size
lower_bound, upper_bound = compute_unsigned_real_bounds(
high_bit_size,
low_bit_size,
)
if real_value < lower_bound or real_value > upper_bound:
with pytest.raises(ValueOutOfBounds):
encoder(base_integer_value)
return
expected_value = zpad(int_to_big_endian(base_integer_value),
data_byte_size)
encoded_value = encoder(real_value)
assert encoded_value == expected_value
def test_encode_unsigned_fixed(value, value_bit_size, frac_places,
data_byte_size):
if value_bit_size > data_byte_size * 8:
pattern = r'Value byte size exceeds data size'
with pytest.raises(ValueError, match=pattern):
UnsignedFixedEncoder(
value_bit_size=value_bit_size,
frac_places=frac_places,
data_byte_size=data_byte_size,
)
return
encoder = UnsignedFixedEncoder(
value_bit_size=value_bit_size,
frac_places=frac_places,
data_byte_size=data_byte_size,
)
if not is_number(value):
pattern = r'Value `None` of type .*NoneType.* cannot be encoded by UnsignedFixedEncoder'
with pytest.raises(EncodingTypeError, match=pattern):
encoder(value)
return
if UnsignedFixedEncoder.illegal_value_fn(value):
pattern = r'Value .*(NaN|Infinity|-Infinity).* cannot be encoded by UnsignedFixedEncoder'
with pytest.raises(IllegalValue, match=pattern):
encoder(value)
return
lower, upper = compute_unsigned_fixed_bounds(value_bit_size, frac_places)
if value < lower or value > upper:
pattern = (r'Value .* cannot be encoded by UnsignedFixedEncoder: '
r'Cannot be encoded in .* bits')
with pytest.raises(ValueOutOfBounds, match=pattern):
encoder(value)
return
with decimal.localcontext(abi_decimal_context):
residue = value % (TEN**-frac_places)
if residue > 0:
pattern = r'Value .* cannot be encoded by UnsignedFixedEncoder: residue .* outside allowed'
with pytest.raises(IllegalValue, match=pattern):
encoder(value)
return
# Ensure no exception
encoder(value)
def generate_cache_key(value: Any) -> str:
"""
Generates a cache key for the *args and **kwargs
"""
if is_bytes(value):
return hashlib.md5(value).hexdigest()
elif is_text(value):
return generate_cache_key(to_bytes(text=value))
elif is_boolean(value) or is_null(value) or is_number(value):
return generate_cache_key(repr(value))
elif is_dict(value):
return generate_cache_key(
((key, value[key]) for key in sorted(value.keys())))
elif is_list_like(value) or isinstance(value, collections.abc.Generator):
return generate_cache_key("".join(
(generate_cache_key(item) for item in value)))
else:
raise TypeError(
f"Cannot generate cache key for value {value} of type {type(value)}"
)
def type_check_fn(value):
return is_number(value) and not isinstance(value, float)
def encode_int(value):
'''encodes an integer into serialization'''
if not is_number(value) or value < 0 or value >= TT256:
raise Exception("Integer invalid or out of range: %r" % value)
return int_to_big_endian(value)
def type_check_fn(value):
return is_number(value) and not isinstance(value, float)
