posts.invoice, errmsg,

            )

            return

        try:

            rt_requestor = self.rt_client.get_user(ticket['Requestors'][0])

        except (IndexError, rt.RtError):

            rt_requestor = None

        if rt_requestor is None:

            requestor = ''

            requestor_name = ''

        else:

            requestor_name = (

                rt_requestor.get('RealName')

                or ticket.get('CF.{payment-to}')

                or ''

            )

            requestor = f'{requestor_name} <{rt_requestor["EmailAddress"]}>'.strip()

        balance_s = posts.end_balance.format(None)

        raw_balance = -posts.balance()

        if raw_balance != posts.end_balance:

            balance_s = f'{raw_balance} ({balance_s})'

        if contract_links:

            contract_s = ' , '.join(self.rt_wrapper.iter_urls(

                contract_links, missing_fmt='<BROKEN RT LINK: {}>',

            ))

        else:

            contract_s = "NO CONTRACT GOVERNS THIS TRANSACTION"

        projects = [v for v in posts.meta_values('project')

                    if isinstance(v, str)]

        yield "PAYMENT FOR APPROVAL:"

        yield f"REQUESTOR: {requestor}"

        yield f"TOTAL TO PAY: {balance_s}"

        yield f"AGREEMENT: {contract_s}"

        yield f"PAYMENT TO: {ticket.get('CF.{payment-to}') or requestor_name}"

        yield f"PAYMENT METHOD: {ticket.get('CF.{payment-method}', '')}"

        yield f"PROJECT: {', '.join(projects)}"

        yield "\nBEANCOUNT ENTRIES:\n"

        last_txn: Optional[Transaction] = None

        for post in posts:

            txn = post.meta.txn

            if txn is not last_txn:

                last_txn = txn

                txn = self.rt_wrapper.txn_with_urls(txn, '{}')

import abc

import collections

import datetime

import itertools

import operator

import re

import babel.core  # type:ignore[import]

import babel.numbers  # type:ignore[import]

import odf.config  # type:ignore[import]

import odf.element  # type:ignore[import]

import odf.number  # type:ignore[import]

import odf.opendocument  # type:ignore[import]

import odf.style  # type:ignore[import]

import odf.table  # type:ignore[import]

import odf.text  # type:ignore[import]

from decimal import Decimal

from pathlib import Path

from beancount.core import amount as bc_amount

from .. import data

from typing import (

    cast,

    overload,

    Any,

    BinaryIO,

    Callable,

    DefaultDict,

    Dict,

    Generic,

    Iterable,

    Iterator,

    List,

    Mapping,

    MutableMapping,

    Optional,

    Sequence,

    Set,

    Tuple,

    Type,

    TypeVar,

    Union,

)

from ..beancount_types import (

            mapping[post.meta.get(key, default)].append(post)

        for value, posts in mapping.items():

            yield value, cls(posts, _can_own=True)

    def __repr__(self) -> str:

        return f'<{type(self).__name__} {self._postings!r}>'

    @overload

    def __getitem__(self: RelatedType, index: int) -> data.Posting: ...

    @overload

    def __getitem__(self: RelatedType, s: slice) -> RelatedType: ...

    def __getitem__(self: RelatedType,

                    index: Union[int, slice],

    ) -> Union[data.Posting, RelatedType]:

        if isinstance(index, slice):

            return type(self)(self._postings[index], _can_own=True)

        else:

            return self._postings[index]

    def __len__(self) -> int:

        return len(self._postings)

        for post in self:

            try:

            except TypeError:

                pass

    def iter_with_balance(self) -> Iterator[Tuple[data.Posting, Balance]]:

        balance = MutableBalance()

        for post in self:

            balance += post.units

            yield post, balance

    def balance(self) -> Balance:

        for _, balance in self.iter_with_balance():

            pass

        try:

            return balance

        except NameError:

            return Balance()

    def balance_at_cost(self) -> Balance:

        balance = MutableBalance()

        for post in self:

            if post.cost is None:

                balance += post.units

            else:

                number = post.units.number * post.cost.number

                balance += data.Amount(number, post.cost.currency)

        return balance

def test_meta_values_many_types():

    expected = {

        datetime.date(2020, 4, 1),

        Decimal(42),

        testutil.Amount(5),

        'rt:42',

    }

    related = core.RelatedPostings(

        testutil.Posting('Income:Donations', -index, key=value)

        for index, value in enumerate(expected)

    )

    assert related.meta_values('key') == expected

@pytest.mark.parametrize('count', range(3))

def test_all_meta_links_zero(count):

    postings = (

        testutil.Posting('Income:Donations', -n, testkey=str(n))

        for n in range(count)

    )

    related = core.RelatedPostings(

        post._replace(meta=data.Metadata(post.meta))

        for post in postings

    )

def test_all_meta_links_singletons():

    postings = (

        testutil.Posting('Income:Donations', -10, statement=value)

        for value in itertools.chain(

            testutil.NON_LINK_METADATA_STRINGS,

            testutil.LINK_METADATA_STRINGS,

            testutil.NON_STRING_METADATA_VALUES,

        ))

    related = core.RelatedPostings(

        post._replace(meta=data.Metadata(post.meta))

        for post in postings

    )

def test_all_meta_links_multiples():

    postings = (

        testutil.Posting('Income:Donations', -10, approval=' '.join(value))

        for value in itertools.permutations(testutil.LINK_METADATA_STRINGS, 2)

    )

    related = core.RelatedPostings(

        post._replace(meta=data.Metadata(post.meta))

        for post in postings

    )

def test_group_by_meta_zero():

    assert not list(core.RelatedPostings.group_by_meta([], 'metacurrency'))

def test_group_by_meta_one(credit_card_cycle):

    posting = next(post for post in data.Posting.from_entries(credit_card_cycle)

                   if post.account.is_credit_card())

    actual = core.RelatedPostings.group_by_meta([posting], 'metacurrency')

    assert set(key for key, _ in actual) == {'USD'}

def test_group_by_meta_many(two_accruals_three_payments):

    postings = [post for post in data.Posting.from_entries(two_accruals_three_payments)

                if post.account == 'Assets:Receivable:Accounts']

    actual = dict(core.RelatedPostings.group_by_meta(postings, 'metacurrency'))

    assert set(actual) == {'USD', 'EUR'}

    for key, group in actual.items():

        assert 2 <= len(group) <= 3

        assert group.balance().is_zero()

def test_group_by_meta_many_single_posts(two_accruals_three_payments):

    postings = [post for post in data.Posting.from_entries(two_accruals_three_payments)

                if post.account == 'Assets:Receivable:Accounts']

    actual = dict(core.RelatedPostings.group_by_meta(postings, 'metanumber'))

    assert set(actual) == {post.units.number for post in postings}