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)