NPO-Accounting/conservancy_beancount Changeset - cd1766adcf14

Changeset - cd1766adcf14

Parent rev.

Child rev.

[Not reviewed]

0 2 0

Brett Smith - 4 years ago 2020-06-09 13:04:27
brettcsmith@brettcsmith.org

reports: Balance.__eq__ respects tolerance.

2 files changed with 56 insertions and 4 deletions:

conservancy_beancount/reports/core.py

tests/test_reports_balance.py

0 comments (0 inline, 0 general)

conservancy_beancount/reports/core.py

➞

Show inline comments

@@ ... / @@ -111,76 +111,89 @@ class Balance(Mapping[str, data.Amount]): @@
                    other: Union[data.Amount, 'Balance'],
     ) -> None:
         if isinstance(other, Balance):
             for amount in other.values():
                 self._add_amount(currency_map, amount)
         else:
             self._add_amount(currency_map, other)
     def __repr__(self) -> str:
         values = [repr(amt) for amt in self.values()]
         return f"{type(self).__name__}({values!r})"
     def __str__(self) -> str:
         return self.format()
     def __abs__(self: BalanceType) -> BalanceType:
         return type(self)(bc_amount.abs(amt) for amt in self.values())
     def __add__(self: BalanceType, other: Union[data.Amount, 'Balance']) -> BalanceType:
         retval_map = self._currency_map.copy()
         self._add_other(retval_map, other)
         return type(self)(retval_map.values())
     def __eq__(self, other: Any) -> bool:
         if (self.is_zero()
             and isinstance(other, Balance)
             and other.is_zero()):
             return True
         if isinstance(other, Balance):
             clean_self = self.clean_copy()
             clean_other = other.clean_copy()
             return len(clean_self) == len(clean_other) and all(
                 clean_self[key] == clean_other.get(key) for key in clean_self
+            )
         else:
             return super().__eq__(other)
     def __neg__(self: BalanceType) -> BalanceType:
         return type(self)(-amt for amt in self.values())
     def __pos__(self: BalanceType) -> BalanceType:
         return self
     def __getitem__(self, key: str) -> data.Amount:
         return self._currency_map[key]
     def __iter__(self) -> Iterator[str]:
         return iter(self._currency_map)
     def __len__(self) -> int:
         return len(self._currency_map)
     def _all_amounts(self,
                      op_func: Callable[[DecimalCompat, DecimalCompat], bool],
                      operand: DecimalCompat,
     ) -> bool:
         return all(op_func(amt.number, operand) for amt in self.values())
     def copy(self: BalanceType) -> BalanceType:
         return type(self)(self.values())
     def clean_copy(self: BalanceType, tolerance: Optional[Decimal]=None) -> BalanceType:
         if tolerance is None:
             tolerance = self.tolerance
         return type(self)(
             amount for amount in self.values()
             if abs(amount.number) >= tolerance
+        )
     @staticmethod
     def within_tolerance(dec: DecimalCompat, tolerance: DecimalCompat) -> bool:
         dec = cast(Decimal, dec)
         return abs(dec) < tolerance
     def eq_zero(self) -> bool:
         """Returns true if all amounts in the balance == 0, within tolerance."""
         return self._all_amounts(self.within_tolerance, self.tolerance)
     is_zero = eq_zero
     def ge_zero(self) -> bool:
         """Returns true if all amounts in the balance >= 0, within tolerance."""
         op_func = operator.gt if self.tolerance else operator.ge
         return self._all_amounts(op_func, -self.tolerance)
     def le_zero(self) -> bool:
         """Returns true if all amounts in the balance <= 0, within tolerance."""
         op_func = operator.lt if self.tolerance else operator.le
         return self._all_amounts(op_func, self.tolerance)
     def format(self,
                fmt: Optional[str]='#,#00.00 ¤¤',
                sep: str=', ',

tests/test_reports_balance.py

➞

Show inline comments

@@ ... / @@ -13,48 +13,50 @@ @@
+#
 # You should have received a copy of the GNU Affero General Public License
 # along with this program.  If not, see <https://www.gnu.org/licenses/>.
 import itertools
 from decimal import Decimal
 import pytest
 from . import testutil
 import babel.numbers
 from conservancy_beancount.reports import core
 DEFAULT_STRINGS = [
     ({}, "Zero balance"),
     ({'JPY': 0, 'BRL': 0}, "Zero balance"),
     ({'USD': '20.00'}, "20.00 USD"),
     ({'EUR': '50.00', 'GBP': '80.00'}, "80.00 GBP, 50.00 EUR"),
     ({'JPY': '-5500.00', 'BRL': '-8500.00'}, "-8,500.00 BRL, -5,500 JPY"),
+]
 TOLERANCES = [Decimal(n) for n in ['.1', '.01', '.001', 0]]
 def amounts_from_map(currency_map):
     for code, number in currency_map.items():
         yield testutil.Amount(number, code)
 def test_empty_balance():
     balance = core.Balance()
     assert not balance
     assert len(balance) == 0
     assert balance.is_zero()
     with pytest.raises(KeyError):
         balance['USD']
 @pytest.mark.parametrize('currencies', [
     'USD',
     'EUR GBP',
     'JPY INR BRL',
 ])
 def test_zero_balance(currencies):
     keys = currencies.split()
     balance = core.Balance(testutil.Amount(0, key) for key in keys)
     assert balance
     assert len(balance) == len(keys)
     assert balance.is_zero()
     assert all(balance[key].number == 0 for key in keys)
@@ ... / @@ -198,48 +200,57 @@ def test_neg(mapping): @@
     {'JPY': 40, 'USD': 0, 'EUR': -50},
 ])
 def test_pos(mapping):
     amounts = frozenset(amounts_from_map(mapping))
     actual = +core.Balance(amounts)
     assert set(actual.values()) == amounts
 @pytest.mark.parametrize('map1,map2,expected', [
     ({}, {}, True),
     ({}, {'USD': 0}, True),
     ({}, {'EUR': 1}, False),
     ({'USD': 1}, {'EUR': 1}, False),
     ({'USD': 1}, {'USD': '1.0'}, True),
     ({'USD': 1}, {'USD': '1.0', 'EUR': '2.0'}, False),
     ({'USD': 1, 'BRL': '2.0'}, {'USD': '1.0', 'EUR': '2.0'}, False),
     ({'USD': 1, 'EUR': 2, 'BRL': '3.0'}, {'USD': '1.0', 'EUR': '2.0'}, False),
     ({'USD': 1, 'EUR': 2}, {'USD': '1.0', 'EUR': '2.0'}, True),
 ])
 def test_eq(map1, map2, expected):
     bal1 = core.Balance(amounts_from_map(map1))
     bal2 = core.Balance(amounts_from_map(map2))
     actual = bal1 == bal2
     assert actual == expected
 @pytest.mark.parametrize('tolerance', TOLERANCES)
 def test_eq_considers_tolerance(tolerance):
     tolerance = Decimal(tolerance)
     mapping = {'EUR': 100, 'USD': '.002'}
     bal1 = core.Balance(amounts_from_map(mapping))
     mapping['USD'] = '.004'
     bal2 = core.Balance(amounts_from_map(mapping), tolerance)
     assert (bal1 == bal2) == (tolerance > Decimal('.002'))
 @pytest.mark.parametrize('number,currency', {
     (50, 'USD'),
     (-50, 'USD'),
     (50000, 'BRL'),
     (-4000, 'BRL'),
 })
 def test_add_amount(number, currency):
     start_amount = testutil.Amount(500, 'USD')
     start_bal = core.Balance([start_amount])
     add_amount = testutil.Amount(number, currency)
     actual = start_bal + add_amount
     if currency == 'USD':
         assert len(actual) == 1
         assert actual['USD'] == testutil.Amount(500 + number)
     else:
         assert len(actual) == 2
         assert actual['USD'] == start_amount
         assert actual[currency] == add_amount
     assert start_bal == {'USD': start_amount}
 @pytest.mark.parametrize('number,currency', {
     (50, 'USD'),
     (-50, 'USD'),
     (50000, 'BRL'),
@@ ... / @@ -273,48 +284,76 @@ def test_add_balance(mapping): @@
         expect_numbers[code] = expect_numbers.get(code, 0) + number
     add_bal = core.Balance(amounts_from_map(mapping))
     actual = start_bal + add_bal
     expected = core.Balance(amounts_from_map(expect_numbers))
     assert actual == expected
 @pytest.mark.parametrize('mapping', [
     {},
     {'USD': 0},
     {'EUR': 10},
     {'JPY': 20, 'BRL': 30},
     {'EUR': -15},
     {'JPY': -25, 'BRL': -35},
     {'JPY': 40, 'USD': 0, 'EUR': -50},
 ])
 def test_iadd_balance(mapping):
     expect_numbers = {'USD': 500, 'BRL': 40000}
     balance = core.MutableBalance(amounts_from_map(expect_numbers))
     for code, number in mapping.items():
         expect_numbers[code] = expect_numbers.get(code, 0) + number
     balance += core.Balance(amounts_from_map(mapping))
     expected = core.Balance(amounts_from_map(expect_numbers))
     assert balance == expected
 def test_copy():
     amounts = frozenset(amounts_from_map({'USD': 10, 'EUR': '.001'}))
     # Use a ridiculous tolerance to test it doesn't matter.
     actual = core.Balance(amounts, 100).copy()
     assert frozenset(actual.values()) == amounts
 @pytest.mark.parametrize('tolerance', TOLERANCES)
 def test_clean_copy(tolerance):
     usd = testutil.Amount(10)
     eur = testutil.Amount('.002', 'EUR')
     actual = core.Balance([usd, eur], tolerance).clean_copy()
     if tolerance < eur.number:
         expected = {usd, eur}
     else:
         expected = {usd}
     assert frozenset(actual.values()) == expected
 @pytest.mark.parametrize('tolerance', TOLERANCES)
 def test_clean_copy_arg(tolerance):
     usd = testutil.Amount(10)
     eur = testutil.Amount('.002', 'EUR')
     actual = core.Balance([usd, eur], 0).clean_copy(tolerance)
     if tolerance < eur.number:
         expected = {usd, eur}
     else:
         expected = {usd}
     assert frozenset(actual.values()) == expected
 @pytest.mark.parametrize('mapping,expected', DEFAULT_STRINGS)
 def test_str(mapping, expected):
     balance = core.Balance(amounts_from_map(mapping))
     assert str(balance) == expected
 @pytest.mark.parametrize('mapping,expected', DEFAULT_STRINGS)
 def test_format_defaults(mapping, expected):
     balance = core.Balance(amounts_from_map(mapping))
     assert balance.format() == expected
 @pytest.mark.parametrize('fmt,expected', [
     ('¤##0.0', '¥5000, -€1500.00'),
     ('#,#00.0¤¤', '5,000JPY, -1,500.00EUR'),
     ('¤+##0.0;¤-##0.0', '¥+5000, €-1500.00'),
     ('#,#00.0 ¤¤;(#,#00.0 ¤¤)', '5,000 JPY, (1,500.00 EUR)'),
 ])
 def test_format_fmt(fmt, expected):
     amounts = [testutil.Amount(5000, 'JPY'), testutil.Amount(-1500, 'EUR')]
     balance = core.Balance(amounts)
     assert balance.format(fmt) == expected
 @pytest.mark.parametrize('sep', [
     '; ',
     '—',

0 comments (0 inline, 0 general)