def entities(self) -> Iterator[MetaValue]:

        yield from self.accrued_entities

        yield from self.paid_entities.difference(self.accrued_entities)

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

        account_ok = isinstance(self.account, 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

            yield (self.invoice, self)

            return

        groups = collections.defaultdict(list)

        for post in self:

        type_self = type(self)

        for group_key, posts in groups.items():

            yield group_key, type_self(posts, _can_own=True)

    def report_inconsistencies(self) -> Iterable[Error]:

        for field_name, get_func in self._FIELDS.items():

class BaseReport:

    def __init__(self, out_file: TextIO) -> None:

        self.out_file = out_file

        self.logger = logger.getChild(type(self).__name__)

        raise NotImplementedError("BaseReport._report")

    def run(self, groups: PostGroups) -> None:

        for index, invoice in enumerate(groups):

                print(line, file=self.out_file)

class AgingODS(core.BaseODS[AccrualPostings, Optional[data.Account]]):

    COLUMNS = [

        'Date',

        ))

        self.ods.write(rows)

        self.ods.save_file(self.out_bin)

class BalanceReport(BaseReport):

        posts = posts.since_last_nonzero()

        date_s = posts[0].meta.date.strftime('%Y-%m-%d')

        if index:

            yield ""

        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)

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

        if parsed is None:

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

        else:

            return parsed

        posts = posts.since_last_nonzero()

        try:

            ticket_id, _ = self._primary_rt_id(posts)

            ticket = self.rt_client.get_ticket(ticket_id)

            # Note we only use this when ticket is None.

            errmsg = f"ticket {ticket_id} not found"

        except (ValueError, rt.RtError) as error:

            ticket = None

            errmsg = error.args[0]

        if ticket is None:

            self.logger.error(

                "can't generate outgoings report for %s because no RT ticket available: %s",

            )

            return

        try:

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

        except (IndexError, rt.RtError):

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    author='Software Freedom Conservancy',

    author_email='info@sfconservancy.org',

    license='GNU AGPLv3+',

    install_requires=[

        'babel>=2.6',  # Debian:python3-babel

import collections

import copy

import datetime

import io

import itertools

import logging

import re

import babel.numbers

import odf.opendocument

import odf.table

import odf.text

    for post, err in itertools.zip_longest(txn.postings, errors):

        assert err.message == f'inconsistent cost for invoice {invoice}: {post.cost}'

        assert err.entry is txn

        assert err.source.get('lineno') == post.meta['lineno']

def test_make_consistent_not_needed():

    other_meta = {key: f'{key}.pdf' for key in CONSISTENT_METADATA}

    # We intentionally make inconsistencies in "minor" metadata that shouldn't

    # split out the group.

    txn = testutil.Transaction(postings=[

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = related.make_consistent()

    actual_key, actual_postings = next(consistent)

    assert actual_postings is related

    assert next(consistent, None) is None

@pytest.mark.parametrize('acct_name,invoice,day', testutil.combine_values(

    ACCOUNTS,

    ['FIXME', '', None, *testutil.NON_STRING_METADATA_VALUES],

    itertools.count(1),

))

def test_make_consistent_bad_invoice(acct_name, invoice, day):

    txn = testutil.Transaction(date=datetime.date(2019, 1, day), postings=[

        for index in range(1, 4)

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == 1

    assert actual

    assert len(actual) == 3

    for act_post, exp_post in zip(actual, txn.postings):

        assert act_post.units == exp_post.units

        assert act_post.meta.get('invoice') == invoice

def test_make_consistent_across_accounts():

    invoice = 'Invoices/CrossAccount.pdf'

    txn = testutil.Transaction(date=datetime.date(2019, 2, 1), postings=[

        for acct_name in ACCOUNTS

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == len(ACCOUNTS)

def test_make_consistent_both_invoice_and_account():

    txn = testutil.Transaction(date=datetime.date(2019, 2, 2), postings=[

        (acct_name, 150) for acct_name in ACCOUNTS

    ])

    related = accrual.AccrualPostings(data.Posting.from_txn(txn))

    consistent = dict(related.make_consistent())

    assert len(consistent) == len(ACCOUNTS)

def check_output(output, expect_patterns):

    output.seek(0)

    testutil.check_lines_match(iter(output), expect_patterns)

def run_outgoing(invoice, postings, rt_client=None):

def test_aging_report_date_cutoffs(accrual_postings, date, recv_end, pay_end):

    expect_recv = AGING_AR[:recv_end]

    expect_pay = AGING_AP[:pay_end]

    output = run_aging_report(accrual_postings, date)

    check_aging_ods(output, date, expect_recv, expect_pay)

def run_main(arglist, config=None):

    if config is None:

        config = testutil.TestConfig(

            books_path=testutil.test_path('books/accruals.beancount'),

            rt_client=RTClient(),

        )