RECEIVABLE = Account('Assets:Receivable', lambda bal: bal)

    @classmethod

    def account_names(cls) -> Iterator[str]:

        return (acct.value.name for acct in cls)

    @classmethod

    def classify(cls, related: core.RelatedPostings) -> 'AccrualAccount':

        for account in cls:

            account_name = account.value.name

            if all(post.account.is_under(account_name) for post in related):

                return account

        raise ValueError("unrecognized account set in related postings")

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'),

        'entity': _meta_getter('entity'),

        'invoice': _meta_getter('invoice'),

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

    }

    INCONSISTENT = Sentinel()

    __slots__ = (

        'accrual_type',

        'final_bal',

        'account',

        'accounts',

        'contract',

        'contracts',

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

        if account_ok and invoice_ok:

            yield (self.invoice, self)

            return

        groups = collections.defaultdict(list)

        for post in self:

            if invoice_ok:

                key = f'{self.invoice} {post.account}'

            else:

                key = f'{post.account} {post.meta.get("entity")} {post.meta.get("invoice")}'

            groups[key].append(post)

        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():

            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)

    def is_paid(self, default: Optional[bool]=None) -> Optional[bool]:

        if self.accrual_type is None:

            return default

        else:

            return self.final_bal.le_zero()

    def is_zero(self, default: Optional[bool]=None) -> Optional[bool]:

        if self.accrual_type is None:

            return default

        else:

            return self.final_bal.is_zero()

    def since_last_nonzero(self) -> 'AccrualPostings':

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

            if balance.is_zero():

                start_index = index

        try:

            empty = start_index == index

        except NameError:

            empty = True

        return self if empty else self[start_index + 1:]

2020-03-06 * "EarlyBird" "Payment for payment from previous FY"

  rt-id: "rt:44"

  invoice: "rt:44/440"

  Liabilities:Payable:Accounts  125 USD

  Assets:Checking  -125 USD

2020-03-30 * "EarlyBird" "Travel reimbursement"

  rt-id: "rt:490"

  invoice: "rt:490/4900"

  Liabilities:Payable:Accounts  -75 USD

  Expenses:Travel  75 USD

2020-04-30 ! "Vendor" "Travel reimbursement"

  rt-id: "rt:310"

  contract: "rt:310/3100"

  invoice: "FIXME"  ; still waiting on them to send it

  Liabilities:Payable:Accounts  -200 USD

  Expenses:Travel  200 USD

2020-05-05 * "DonorA" "Donation pledge"

  rt-id: "rt:505"

  invoice: "rt:505/5050"

  approval: "rt:505/5040"

2020-05-10 * "Lawyer" "April legal services"

  rt-id: "rt:510"

  invoice: "rt:510/5100"

  contract: "rt:510/4000"

  Expenses:Services:Legal  200.00 USD

  Liabilities:Payable:Accounts  -200.00 USD

2020-05-15 * "MatchingProgram" "May matched donations"

  invoice: "rt://ticket/515/attachments/5150"

  approval: "rt://ticket/515/attachments/5140"

  Income:Donations  -1500.00 USD

  Assets:Receivable:Accounts  1500.00 USD

2020-05-20 * "DonorA" "Donation made"

  rt-id: "rt:505"

  invoice: "rt:505/5050"

  receipt: "DonorAWire.pdf"

2020-05-25 * "Lawyer" "May payment"

  rt-id: "rt:510"

  invoice: "rt:510/5100"

  Liabilities:Payable:Accounts  200.00 USD

  contract: "rt:510/4000"

  Assets:Checking  -200.00 USD

  receipt: "rt:510/5105"

2020-06-10 * "Lawyer" "May legal services"

  rt-id: "rt:510"

  invoice: "rt:510/6100"

  contract: "rt:510/4000"

  Expenses:Services:Legal  220.00 USD

  Liabilities:Payable:Accounts  -220.00 USD

2020-06-12 * "Lawyer" "Additional legal fees for May"

  rt-id: "rt:510"

  invoice: "rt:510/6100"

  contract: "rt:510/4000"

  Expenses:FilingFees  60.00 USD

  Liabilities:Payable:Accounts  -60.00 USD

    assert accrual.ReportType.by_name(arg.title()).value is expected

    assert accrual.ReportType.by_name(arg.upper()).value is expected

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

    'unknown',

    'blance',

    'outgong',

])

def test_report_type_by_unknown_name(arg):

    # Raising ValueError helps argparse generate good messages.

    with pytest.raises(ValueError):

        accrual.ReportType.by_name(arg)

@pytest.mark.parametrize('acct_name', ACCOUNTS)

def test_accrual_postings_consistent_account(acct_name):

    meta = {'invoice': '{acct_name} invoice.pdf'}

    txn = testutil.Transaction(postings=[

        (acct_name, 50, meta),

        (acct_name, 25, meta),

    ])

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

    assert related.account == acct_name

    assert related.accounts == {acct_name}

@pytest.mark.parametrize('meta_key,acct_name', testutil.combine_values(

    CONSISTENT_METADATA,

    ACCOUNTS,

))

def test_accrual_postings_consistent_metadata(meta_key, acct_name):

    meta_value = f'{meta_key}.pdf'

    meta = {

        meta_key: meta_value,

        'invoice': f'invoice with {meta_key}.pdf',

    }

    txn = testutil.Transaction(postings=[

        (acct_name, 70, meta),

        (acct_name, 35, meta),

    ])

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

    attr_name = meta_key.replace('-', '_')

    assert getattr(related, attr_name) == meta_value

    assert getattr(related, f'{attr_name}s') == {meta_value}

def test_accrual_postings_inconsistent_account():

    meta = {'invoice': 'invoice.pdf'}

    txn = testutil.Transaction(postings=[

        (acct_name, index, meta)

        for index, acct_name in enumerate(ACCOUNTS)

    ])

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

    assert related.account is related.INCONSISTENT

    assert related.accounts == set(ACCOUNTS)

@pytest.mark.parametrize('meta_key,acct_name', testutil.combine_values(

    CONSISTENT_METADATA,

    ACCOUNTS,

))

def test_accrual_postings_inconsistent_metadata(meta_key, acct_name):

    invoice = 'invoice with {meta_key}.pdf'

    meta_value = f'{meta_key}.pdf'

    txn = testutil.Transaction(postings=[

        (acct_name, 20, {'invoice': invoice, meta_key: meta_value}),

        (acct_name, 35, {'invoice': invoice}),

    ])

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

    attr_name = meta_key.replace('-', '_')

    assert getattr(related, attr_name) is related.INCONSISTENT

    assert getattr(related, f'{attr_name}s') == {meta_value, None}

@pytest.mark.parametrize('meta_key,account', testutil.combine_values(

    CONSISTENT_METADATA,

    ACCOUNTS,

))

def test_consistency_check_when_consistent(meta_key, account):

    invoice = f'test-{meta_key}-invoice'

    meta_value = f'test-{meta_key}-value'

    meta = {