@classmethod

    def filter_paid_accruals(cls, groups: PostGroups) -> PostGroups:

        return {

            key: related

            for key, related in groups.items()

            if not cls.classify(related).value.balance_paid(related.balance())

        }

class AccrualPostings(core.RelatedPostings):

    def _meta_getter(key: MetaKey) -> Callable[[data.Posting], MetaValue]:  # type:ignore[misc]

        def meta_getter(post: data.Posting) -> MetaValue:

            return post.meta.get(key)

        return meta_getter

    _FIELDS: Dict[str, Callable[[data.Posting], MetaValue]] = {

        'account': operator.attrgetter('account'),

        'contract': _meta_getter('contract'),

        'cost': operator.attrgetter('cost'),

        'entity': _meta_getter('entity'),

        'invoice': _meta_getter('invoice'),

        'purchase_order': _meta_getter('purchase-order'),

    }

    INCONSISTENT = Sentinel()

    __slots__ = (

        'accrual_type',

        'account',

        'accounts',

        'contract',

        'contracts',

        'cost',

        'costs',

        'entity',

        'entitys',

        'entities',

        'invoice',

        'invoices',

        'purchase_order',

        'purchase_orders',

    )

    def __init__(self,

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

                 *,

                 _can_own: bool=False,

    ) -> None:

        super().__init__(source, _can_own=_can_own)

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

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

        self.account: Union[data.Account, Sentinel]

        self.entitys: FrozenSet[MetaValue]

        self.invoice: Union[MetaValue, Sentinel]

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

            values = frozenset(get_func(post) for post in self)

            setattr(self, f'{name}s', values)

            if len(values) == 1:

                one_value = next(iter(values))

            else:

                one_value = self.INCONSISTENT

            setattr(self, name, one_value)

        # Correct spelling = bug prevention for future users of this class.

        self.entities = self.entitys

        if self.account is self.INCONSISTENT:

            self.accrual_type: Optional[AccrualAccount] = None

        else:

            self.accrual_type = AccrualAccount.classify(self)

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

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

            if getattr(self, field_name) is self.INCONSISTENT:

                for post in self:

                    errmsg = 'inconsistent {} for invoice {}: {}'.format(

                        field_name.replace('_', '-'),

                        self.invoice or "<none>",

                        get_func(post),

                    )

                    yield Error(post.meta, errmsg, post.meta.txn)

class BaseReport:

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

        self.out_file = out_file

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

    def _since_last_nonzero(self, posts: AccrualPostings) -> AccrualPostings:

        for index, (post, balance) in enumerate(posts.iter_with_balance()):

            if balance.is_zero():

                start_index = index

        try:

            empty = start_index == index

        except NameError:

"""test_reports_accrual - Unit tests for accrual report"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import collections

import copy

import io

import itertools

import logging

import re

import pytest

from . import testutil

from beancount import loader as bc_loader

from conservancy_beancount import data

from conservancy_beancount import rtutil

from conservancy_beancount.reports import accrual

from conservancy_beancount.reports import core

_accruals_load = bc_loader.load_file(testutil.test_path('books/accruals.beancount'))

ACCRUALS_COUNT = sum(

    1

    for entry in _accruals_load[0]

    for post in getattr(entry, 'postings', ())

    if post.account.startswith(('Assets:Receivable:', 'Liabilities:Payable:'))

)

ACCOUNTS = [

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

    errors = list(related.report_inconsistencies())

    for exp_lineno, (actual, exp_msg) in enumerate(itertools.zip_longest(errors, [

            f'inconsistent {meta_key} for invoice {invoice}: credit',

            f'inconsistent {meta_key} for invoice {invoice}: debit',

    ]), 1):

        assert actual.message == exp_msg

        assert actual.entry is txn

        assert actual.source.get('lineno') == exp_lineno

def test_consistency_check_cost():

    account = ACCOUNTS[0]

    invoice = 'test-cost-invoice'

    txn = testutil.Transaction(postings=[

        (account, 100, 'EUR', ('1.1251', 'USD'), {'invoice': invoice, 'lineno': 1}),

        (account, -100, 'EUR', ('1.125', 'USD'), {'invoice': invoice, 'lineno': 2}),

    ])

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

    errors = list(related.report_inconsistencies())

    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 check_output(output, expect_patterns):

    output.seek(0)

    testutil.check_lines_match(iter(output), expect_patterns)

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

    if rt_client is None:

        rt_client = RTClient()

    if not isinstance(postings, core.RelatedPostings):

        postings = accruals_by_meta(postings, invoice, wrap_type=accrual.AccrualPostings)

    output = io.StringIO()

    report = accrual.OutgoingReport(rt_client, output)

    report.run({invoice: postings})

    return output

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

    ('rt:505/5050', "Zero balance outstanding since 2020-05-05"),

    ('rt:510/5100', "Zero balance outstanding since 2020-05-10"),

    ('rt:510/6100', "-280.00 USD outstanding since 2020-06-10"),

    ('rt://ticket/515/attachments/5150', "1,500.00 USD outstanding since 2020-05-15",),

])

def test_balance_report(accrual_postings, invoice, expected, caplog):

    related = accruals_by_meta(accrual_postings, invoice, wrap_type=accrual.AccrualPostings)

    output = io.StringIO()

    report = accrual.BalanceReport(output)