balance in that currency.

    """

    __slots__ = ('_currency_map',)

    def __init__(self,

                 source: Union[Iterable[Tuple[str, data.Amount]],

                               Mapping[str, data.Amount]]=(),

    ) -> None:

        if isinstance(source, Mapping):

            source = source.items()

        self._currency_map = {

            currency: amount.number for currency, amount in source

        }

    def __repr__(self) -> str:

        return f"{type(self).__name__}({self._currency_map!r})"

    def __str__(self) -> str:

        amounts = [amount for amount in self.values() if amount.number]

        if not amounts:

            return "Zero balance"

        amounts.sort(key=lambda amt: abs(amt.number), reverse=True)

        return ', '.join(str(amount) for amount in amounts)

    def __getitem__(self, key: str) -> data.Amount:

        return data.Amount(self._currency_map[key], key)

    def __iter__(self) -> Iterator[str]:

        return iter(self._currency_map)

    def __len__(self) -> int:

        return len(self._currency_map)

    def is_zero(self) -> bool:

        return all(number == 0 for number in self._currency_map.values())

class MutableBalance(Balance):

    __slots__ = ()

    def add_amount(self, amount: data.Amount) -> None:

        try:

            self._currency_map[amount.currency] += amount.number

        except KeyError:

            self._currency_map[amount.currency] = amount.number

class RelatedPostings(Sequence[data.Posting]):

    assert all(balance[key].number == 0 for key in keys)

    assert all(balance[key].currency == key for key in keys)

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

    'USD',

    'EUR GBP',

    'JPY INR BRL',

])

def test_nonzero_balance(currencies):

    amounts = testutil.balance_map(zip(currencies.split(), itertools.count(110, 100)))

    balance = core.Balance(amounts.items())

    assert balance

    assert len(balance) == len(amounts)

    assert not balance.is_zero()

    assert all(balance[key] == amt for key, amt in amounts.items())

def test_mixed_balance():

    amounts = testutil.balance_map(USD=0, EUR=120)

    balance = core.Balance(amounts.items())

    assert balance

    assert len(balance) == 2

    assert not balance.is_zero()

    assert all(balance[key] == amt for key, amt in amounts.items())

@pytest.mark.parametrize('balance_map_kwargs,expected', [

    ({}, "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': '-55.00', 'BRL': '-85.00'}, "-85.00 BRL, -55.00 JPY"),

])

def test_str(balance_map_kwargs, expected):

    amounts = testutil.balance_map(**balance_map_kwargs)

    assert str(core.Balance(amounts.items())) == expected