def test_cosmos_overflow(self):
"""Analog for this test:
https://github.com/cosmos/cosmos-sdk/blob/5a2e59ebb23d1d23546f1145d8814a457655935a/types/decimal_test.go#L334
"""
a = Dec("51643150036226787134389711697696177267")
b = Dec("-31798496660535729618459429845579852627")
assert str(a + b) == "19844653375691057515930281852116324640.000000000000000000"
def from_data(cls, data: dict) -> PolicyConstraints:
return cls(
rate_min=Dec(data["rate_min"]),
rate_max=Dec(data["rate_max"]),
cap=Coin.from_data(data["cap"]),
change_max=Dec(data["change_max"]),
)
def test_clamp(self, default_tax_policy, default_tax_rate):
# Analogous test:
# https://github.com/terra-project/core/blob/develop/x/treasury/internal/types/constraint_test.go#L10
tax_policy = default_tax_policy
prev_rate = default_tax_rate
# Case 1: try to update delta > change_max
new_rate = prev_rate + tax_policy.change_max * 2
clamped_rate = tax_policy.clamp(prev_rate, new_rate)
assert prev_rate + tax_policy.change_max == clamped_rate
# Case 2: try to update delta > change_max (negative)
new_rate = prev_rate - tax_policy.change_max * 2
clamped_rate = tax_policy.clamp(prev_rate, new_rate)
assert prev_rate - tax_policy.change_max == clamped_rate
# Case 3: try to update the new rate > min_rate
prev_rate = tax_policy.rate_max
new_rate = prev_rate + Dec.with_prec(1, 3)
clamped_rate = tax_policy.clamp(prev_rate, new_rate)
assert tax_policy.rate_max == clamped_rate
# Case 4: try to update the new rate < minRate
prev_rate = tax_policy.rate_min
new_rate = tax_policy.rate_min - Dec.with_prec(1, 3)
clamped_rate = tax_policy.clamp(prev_rate, new_rate)
assert tax_policy.rate_min == clamped_rate
def test_str_regex(self):
"""`Dec` will only parse strings that match Decimal format: `/^(\-)?(\d+)(\.\d+)?\Z/`
"""
bad_examples = [
"a1.2",
"..2",
"0b00",
"0xdeadb33f",
"0.0.5",
"(626)112-3322",
"2.14E-14",
"42.",
".420",
]
for bad in bad_examples:
with pytest.raises(ValueError):
Dec(bad)
good_examples = [
"0.0",
"42.0",
"333333.213123923402394",
"1127.10102392039129301293230921039",
"13123891823912839123.239482934829348239489",
"-239299920",
"-0000.0",
]
for good in good_examples:
assert isinstance(Dec(good).i, int)
def default_tax_policy():
return PolicyConstraints(
rate_min=Dec.with_prec(5, 4),
rate_max=Dec.with_prec(1, 2),
cap=Coin("usdr", 1),
change_max=Dec.with_prec(25, 5),
)
def test_constructor_copies(self, x):
"""Dec should copy another Dec in the constructor, and the resulting
object should be equivalent but not share the same address in memory.
"""
A = Dec(x)
B = Dec(A)
assert A == B
assert A is not B
def params(
self,
key: Optional[str] = None) -> Union[ApiResponse, dict, Dec, bool]:
res = self._api_get("/distribution/parameters")
p = res
p["community_tax"] = Dec(p["community_tax"])
p["base_proposer_reward"] = Dec(p["base_proposer_reward"])
p["bonus_proposer_reward"] = Dec(p["bonus_proposer_reward"])
return project(res, p[key] if key else JiguBox(p))
def test_cosmos_mul(self):
examples = [
(Dec(-1), Dec(-1), Dec(1)),
(Dec(3), Dec(7), Dec(21)),
(Dec.with_prec(3333, 4), Dec.with_prec(333, 4), Dec.with_prec(1109889, 8),),
]
for x in examples:
assert x[0] * x[1] == x[2]
def test_equality_decimal(self):
assert Dec(Decimal("1.45")) == Decimal("1.45")
assert Dec(Decimal("2342.123232123")) == Decimal("2342.123232123")
assert Dec(Decimal("2332423442.123234234232123")) == Decimal(
"2332423442.123234234232123"
)
# 24, 18 digit decimal precision
assert Dec(Decimal("423412312312312342123123.123234234232123123")) == Decimal(
"423412312312312342123123.123234234232123123"
)
# disregard beyond 19 digits of precision
assert Dec(Decimal("0.1232342342321231233")) == Decimal("0.1232342342321231233")
def params(self, key: Optional[str] = None) -> Union[ApiResponse, Dec, dict]:
res = self._api_get("/market/parameters")
p = JiguBox(res)
p["pool_recovery_period"] = int(p["pool_recovery_period"])
p["base_pool"] = Dec.deserialize(p["base_pool"])
p["min_spread"] = Dec.deserialize(p["min_spread"])
p["tobin_tax"] = Dec.deserialize(p["tobin_tax"])
ill = p["illiquid_tobin_tax_list"]
p["illiquid_tobin_tax_list"] = JiguBox({})
for item in ill:
p["illiquid_tobin_tax_list"][item["denom"]] = Dec(item["tax_rate"])
return project(res, p[key] if key else p)
def test_cosmos_quo(self):
examples = [
(Dec(-1), Dec(-1), Dec(1)),
(Dec(3), Dec(7), Dec.with_prec(428571428571428571, 18)),
(
Dec.with_prec(3333, 4),
Dec.with_prec(333, 4),
Dec("10.009009009009009009"),
),
]
for x in examples:
assert x[0] / x[1] == x[2]
def from_data(cls, data: dict) -> TaxRateUpdateProposal:
data = data["value"]
return cls(
title=data["title"],
description=data["description"],
tax_rate=Dec(data["tax_rate"]),
)
def from_data(cls, data: dict) -> RewardWeightUpdateProposal:
data = data["value"]
return cls(
title=data["title"],
description=data["description"],
reward_weight=Dec(data["reward_weight"]),
)
def test_mul_examples(self):
# TODO: add better examples
examples = [
(Dec("6.3") * Dec("6.5"), Dec("40.95")),
(Dec("27.37") * Dec("36.299"), Dec("993.50363")),
(Dec("-5231.234232") * 5.5, Dec("-28771.788276")),
]
for x in examples:
assert x[0] == x[1]
def test_truncates_beyond_18_digits(self, x, y):
"""If Dec is provided a string representing a number with higher
degree of precision than 18 digits, those extra digits should be truncated.
"""
A = str(x) + "." + y * "7"
r = str(Dec(A)).split(".")
assert r[0] == str(x)
assert len(r[1]) == 18
def clamp(self, prev_rate: Dec, new_rate: Dec):
prev_rate = Dec(prev_rate)
new_rate = Dec(new_rate)
if new_rate < self.rate_min:
new_rate = self.rate_min
elif new_rate > self.rate_max:
new_rate = self.rate_max
delta = new_rate - prev_rate
if new_rate > prev_rate:
if delta > self.change_max:
new_rate = prev_rate + self.change_max
else:
if abs(delta) > self.change_max:
new_rate = prev_rate - self.change_max
return new_rate
def test_make_coin(self, d1):
coin = Coin(d1, "13929")
assert coin.denom == d1
assert coin.amount == 13929
coin = Coin(d1, "0.006250000000000000")
assert coin.denom == d1
assert coin.amount == Dec("0.00625")
def test_converts_decimal_objects(self, x):
"""`Dec` should capture a compatible `Decimal` object and serialize
to 18 digits of precision.
"""
d = Dec(x)
r = str(d).split(".")
if x < 0:
assert d.i < 0
assert int(r[0]) == int(x)
assert len(r[1]) == 18
def from_data(cls, data: dict) -> MsgEditValidator:
data = data["value"]
msd = int(data["min_self_delegation"]) if data["min_self_delegation"] else None
cr = Dec(data["commission_rate"]) if data["commission_rate"] else None
return cls(
Description=data["Description"],
address=data["address"],
commission_rate=cr,
min_self_delegation=msd,
)
def test_serializes_18_digits(self):
examples = [
("0.5", "0.500000000000000000"),
("0.00625", "0.006250000000000000"),
("3913.11", "3913.110000000000000000"),
("-23.11", "-23.110000000000000000"),
("3", "3.000000000000000000"),
("-3", "-3.000000000000000000"),
]
for x in examples:
assert str(Dec(x[0])) == x[1]
def test_simple_check(self):
examples = [
"138875042105.980753034749566779",
"8447.423744387144096286",
"3913.113789811986907029",
"0.500000000000000000",
"0.006250000000000000",
"-23.128250000000000023",
"242.000000000000028422",
"-242.000000000000020422",
]
for x in examples:
assert str(Dec(x)) == x
def test_serializes_zero(self):
Z = "0.000000000000000000"
assert str(Dec(0)) == Z
assert str(Dec("0")) == Z
assert str(Dec("-0")) == Z
assert str(Dec("-00")) == Z
assert str(Dec("-00.0")) == Z
assert str(Dec("-00.0000000000000000000232")) == Z
def __post_init__(self):
if self.commission_rate is not None:
self.commission_rate = Dec(self.commission_rate)
if self.min_self_delegation is not None:
self.min_self_delegation = int(self.min_self_delegation)
self.address = validate_val_address(self.address)
def test_add(self, inc):
assert inc + inc == Dec("0.000000000000000002")
assert (inc + inc).i == 2
def test_sub_properties(self, x, y, zero):
assert Dec(x) - zero == Dec(x)
assert Dec(x) - Dec(y) == -Dec(y) + Dec(x)
assert Dec(x) - Dec(x) == zero
assert isinstance(Dec(x) - Dec(y), Dec)
if not isinstance(y, str):
assert Dec(x) - y == -y + Dec(x)
assert isinstance(Dec(x) - y, Dec)
assert isinstance(y - Dec(x), Dec)
if isinstance(x, int) and isinstance(y, int):
assert Dec(x) - Dec(y) == Dec(x - y)
def test_mul_properties(self, x, y, one):
assume(x != y)
assert Dec(x) * one == Dec(x)
assert Dec(x) * one == one * Dec(x)
assert Dec(x) * Dec(y) == Dec(y) * Dec(x)
if not isinstance(x, str) and not isinstance(y, str):
assert Dec(x) * y == y * Dec(x)
assert isinstance(Dec(x) * y, Dec)
assert isinstance(y * Dec(x), Dec)
if isinstance(x, int) and isinstance(y, int):
assert Dec(x) * Dec(y) == Dec(x * y)
def inc():
nd = Dec(0)
nd.i = 1
return nd
def default_tax_rate():
return Dec.with_prec(1, 3)
def tax_rate(self) -> Union[ApiResponse, Dec]:
res = self._api_get("/treasury/tax_rate") # tr
return project(res, Dec.deserialize(res))
def reward_weight(self) -> Union[ApiResponse, Dec]:
res = self._api_get("/treasury/reward_weight") # rw
return project(res, Dec.deserialize(res))
