) -> bool:

        return all(op_func(amt.number, operand) for amt in self.values())

    def copy(self: BalanceType, tolerance: Optional[Decimal]=None) -> BalanceType:

        if tolerance is None:

            tolerance = self.tolerance

        return type(self)(self.values(), tolerance)

    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),

            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]='#,##0.00 ¤¤',

               sep: str=', ',

               empty: str="Zero balance",

               zero: Optional[str]=None,

               tolerance: Optional[Decimal]=None,

    ) -> str:

        """Formats the balance as a string with the given parameters

        If the balance is completely empty, return ``empty``.

        If the balance is zero (within tolerance) and ``zero`` is specified,

        return ``zero``.

        Otherwise, return a string with each amount in the balance formatted

        as ``fmt``, separated by ``sep``.

        If you set ``fmt`` to None, amounts will be formatted according to the

        user's locale. The default format is Beancount's input format.

        """

        balance = self.clean_copy(tolerance) or self.copy(tolerance)

        if not balance:

            return empty

        elif zero is not None and balance.is_zero():

            return zero

        else:

            amounts = list(balance.values())

            amounts.sort(key=lambda amt: (-abs(amt.number), amt.currency))

            return sep.join(

            )

class MutableBalance(Balance):

    __slots__ = ()

    def __iadd__(self: BalanceType, other: Union[data.Amount, Balance]) -> BalanceType:

        self._add_other(self._currency_map, other)

        return self

    def __isub__(self: BalanceType, other: Union[data.Amount, Balance]) -> BalanceType:

        self._add_other(self._currency_map, -other)

        return self

class RelatedPostings(Sequence[data.Posting]):

    """Collect and query related postings

    This class provides common functionality for collecting related postings

    and running queries on them: iterating over them, tallying their balance,

    etc.

    This class doesn't know anything about how the postings are related. That's

    entirely up to the caller.

    A common pattern is to use this class with collections.defaultdict

    to organize postings based on some key. See the group_by_meta classmethod

    for an example.

    """

    __slots__ = ('_postings',)

    def __init__(self,

                 source: Iterable[data.Posting]=(),

                 *,

                 _can_own: bool=False,

    ) -> None:

        self._postings: List[data.Posting]

        if _can_own and isinstance(source, list):

            self._postings = source

        else:

            self._postings = list(source)

    @classmethod

    def _group_by(cls: Type[RelatedType],

                  postings: Iterable[data.Posting],

                  key: Callable[[data.Posting], T],

    ) -> Iterator[Tuple[T, RelatedType]]:

        mapping: Dict[T, List[data.Posting]] = collections.defaultdict(list)

        for post in postings:

            mapping[key(post)].append(post)

        for value, posts in mapping.items():

            yield value, cls(posts, _can_own=True)

    @classmethod

    def group_by_account(cls: Type[RelatedType],

                         postings: Iterable[data.Posting],

    ) -> Iterator[Tuple[data.Account, RelatedType]]:

        return cls._group_by(postings, operator.attrgetter('account'))

    @classmethod

    def group_by_meta(cls: Type[RelatedType],

                      postings: Iterable[data.Posting],

                      key: MetaKey,

                      default: Optional[MetaValue]=None,

def test_copy_tolerance_arg(tolerance):

    eur = testutil.Amount('.003', 'EUR')

    source = core.Balance([eur])

    new = source.copy(tolerance)

    assert source is not new

    assert dict(source) == dict(new)

    assert new.tolerance == tolerance

@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

    assert actual.tolerance == tolerance

@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

    assert actual.tolerance == tolerance

@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'),

    ('#,##0.0¤¤', '5,000JPY, -1,500.00EUR'),

    ('¤+##0.0;¤-##0.0', '¥+5000, €-1500.00'),

    ('#,##0.0 ¤¤;(#,##0.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',

])

def test_format_sep(sep):

    mapping, expected = DEFAULT_STRINGS[-1]

    expected = expected.replace(', ', sep)

    balance = core.Balance(amounts_from_map(mapping))

    assert balance.format(sep=sep) == expected

    balance = core.Balance([testutil.Amount(*args)])

    assert balance.format(None) == expected

@pytest.mark.parametrize('empty', [

    "N/A",

    "Zero",

    "ø",

])

def test_format_empty(empty):

    balance = core.Balance()

    assert balance.format(empty=empty) == empty

@pytest.mark.parametrize('currency,fmt', itertools.product(

    ['USD', 'JPY', 'BRL'],

    [None, '¤#,##0.00', '###0.00 ¤¤'],

))

def test_format_zero_balance_fmt(currency, fmt):

    zero_amt = testutil.Amount(0, currency)

    nonzero_amt = testutil.Amount(9, currency)

    zero_bal = core.Balance([zero_amt])

    nonzero_bal = core.Balance([nonzero_amt])

    expected = nonzero_bal.format(fmt).replace('9', '0')

    assert zero_bal.format(fmt) == expected

@pytest.mark.parametrize('currency,fmt', testutil.combine_values(

    ['USD', 'JPY', 'BRL'],

    ["N/A", "Zero", "ø"],

))

def test_format_zero_balance_zero_str(currency, fmt):

    zero_amt = testutil.Amount(0, currency)

    zero_bal = core.Balance([zero_amt])

    assert zero_bal.format(zero=fmt) == fmt

@pytest.mark.parametrize('tolerance', TOLERANCES)

def test_format_zero_balance_with_tolerance(tolerance):

    chf = testutil.Amount('.005', 'CHF')

    actual = core.Balance([chf]).format(zero="ø", tolerance=tolerance)

    if tolerance > chf.number:

        assert actual == "ø"

    else:

        assert actual == "0.00 CHF"