# The following type declarations tell mypy about values set in the for

        # loop that are important enough to be referenced directly elsewhere.

        self.account = self._single_item(post.account for post in self)

        if isinstance(self.account, Sentinel):

            self.accrual_type: Optional[AccrualAccount] = None

            norm_func: Callable[[T], T] = lambda x: x

            entity_pred: Callable[[data.Posting], bool] = bool

        else:

            self.accrual_type = AccrualAccount.by_account(self.account)

            norm_func = self.accrual_type.normalize_amount

            entity_pred = lambda post: norm_func(post.units).number > 0

        self.entity = self._single_item(self.entities(entity_pred))

        self.end_balance = norm_func(self.balance_at_cost())

    def _single_item(self, seq: Iterable[T]) -> Union[T, Sentinel]:

        items = iter(seq)

        try:

            item1 = next(items)

        except StopIteration:

            all_same = False

        else:

            all_same = all(item == item1 for item in items)

        return item1 if all_same else self.INCONSISTENT

    def entities(self, pred: Callable[[data.Posting], bool]=bool) -> Iterator[MetaValue]:

        return filters.iter_unique(

            post.meta['entity']

            for post in self

            if pred(post) and 'entity' in post.meta

        )

    def make_consistent(self) -> Iterator[Tuple[MetaValue, 'AccrualPostings']]:

        account_ok = isinstance(self.account, str)

        entity_ok = isinstance(self.entity, str)

        # `'/' in self.invoice` is just our heuristic to ensure that the

        # invoice metadata is "unique enough," and not just a placeholder

        # value like "FIXME". It can be refined if needed.

        invoice_ok = isinstance(self.invoice, str) and '/' in self.invoice

        if account_ok and entity_ok and invoice_ok:

            yield (self.invoice, self)

            return

        groups = collections.defaultdict(list)

        for post in self:

            yield ""

        yield f"{posts.invoice}:"

        yield f"  {posts.balance_at_cost()} outstanding since {date_s}"

class OutgoingReport(BaseReport):

    def __init__(self, rt_client: rt.Rt, out_file: TextIO) -> None:

        super().__init__(out_file)

        self.rt_client = rt_client

        self.rt_wrapper = rtutil.RT(rt_client)

    def _primary_rt_id(self, posts: AccrualPostings) -> rtutil.TicketAttachmentIds:

        rt_ids_count = len(rt_ids)

        if rt_ids_count != 1:

            raise ValueError(f"{rt_ids_count} rt-id links found")

        parsed = rtutil.RT.parse(rt_ids.pop())

        if parsed is None:

            raise ValueError("rt-id is not a valid RT reference")

        else:

            return parsed

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        posts = posts.since_last_nonzero()

        try:

        return len(self._postings)

    def _all_meta_links(self, key: MetaKey) -> Iterator[str]:

        for post in self:

            try:

                yield from post.meta.get_links(key)

            except TypeError:

                pass

    def all_meta_links(self, key: MetaKey) -> Iterator[str]:

        return filters.iter_unique(self._all_meta_links(key))

    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:

def test_all_meta_links_multiples():

    related = core.RelatedPostings(testutil.Posting(

        'Income:Donations', -10, approval=' '.join(value), _meta_type=data.Metadata,

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

    assert set(related.all_meta_links('approval')) == testutil.LINK_METADATA_STRINGS

def test_all_meta_links_preserves_order():

    related = core.RelatedPostings(testutil.Posting(

        'Income:Donations', -10, approval=c, _meta_type=data.Metadata,

    ) for c in '121323')

    assert list(related.all_meta_links('approval')) == list('123')

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']