update_available = available_hooks.update

                key = token

            try:

                update_set = self.group_hooks_map[key]

            except KeyError:

                raise ValueError("configuration refers to unknown hooks {!r}".format(key)) from None

            else:

                update_available(update_set)

        return {key: [hook() for hook in self.group_hooks_map[key] & available_hooks]

                for key in self.DIRECTIVES}

HOOK_REGISTRY = HookRegistry()

HOOK_REGISTRY.import_hooks('.meta_expense_allocation', 'MetaExpenseAllocation')

HOOK_REGISTRY.import_hooks('.meta_tax_implication', 'MetaTaxImplication')

def run(entries, options_map, config='', hook_registry=HOOK_REGISTRY):

    errors = []

    hooks = hook_registry.group_by_directive(config)

    for entry in entries:

        entry_type = type(entry).__name__

        for hook in hooks[entry_type]:

            errors.extend(hook.run(entry))

        if entry_type == 'Transaction':

                for hook in hooks['Posting']:

    return entries, errors

class PostingChecker:

    """Base class to normalize posting metadata from an enum."""

    # This class provides basic functionality to filter postings, normalize

    # metadata values, and set default values.

    # Subclasses should set:

    # * METADATA_KEY: A string with the name of the metadata key to normalize.

    # * ACCOUNTS: Only check postings that match these account names.

    #   Can be a tuple of account prefix strings, or a regexp.

    # * VALUES_ENUM: A MetadataEnum with allowed values and aliases.

    # Subclasses may wish to override _default_value and _should_check.

    # See below.

    HOOK_GROUPS = frozenset(['Posting', 'metadata'])

    ACCOUNTS = ('',)

    TXN_DATE_RANGE = _GenericRange(DEFAULT_START_DATE, DEFAULT_STOP_DATE)

    VALUES_ENUM = {}

    def _meta_get(self, txn, post, key, default=None):

        try:

            return post.meta[key]

        except (KeyError, TypeError):

            return txn.meta.get(key, default)

        if post.meta is None:

    # If the posting does not specify METADATA_KEY, the hook calls

    # _default_value to get a default. This method should either return

    # a value string from METADATA_ENUM, or else raise InvalidMetadataError.

    # This base implementation does the latter.

    def _default_value(self, txn, post):

        raise errormod.InvalidMetadataError(txn, post, self.METADATA_KEY)

    # The hook calls _should_check on every posting and only checks postings

    # when the method returns true. This base method checks the transaction

    # date is in TXN_DATE_RANGE, and the posting account name matches ACCOUNTS.

    def _should_check(self, txn, post):

        ok = txn.date in self.TXN_DATE_RANGE

        if isinstance(self.ACCOUNTS, tuple):

            ok = ok and post.account.startswith(self.ACCOUNTS)

        else:

            ok = ok and re.search(self.ACCOUNTS, post.account)

        return ok

    def run(self, txn, post):

        errors = []

        if not self._should_check(txn, post):

            return errors

        source_value = self._meta_get(txn, post, self.METADATA_KEY)

from conservancy_beancount.plugin import meta_expense_allocation

VALID_VALUES = {

    'program': 'program',

    'administration': 'administration',

    'fundraising': 'fundraising',

    'admin': 'administration',

}

INVALID_VALUES = {

    'invalid',

    'porgram',

    'adimn',

    'fundrasing',

    '',

}

@pytest.mark.parametrize('src_value,set_value', VALID_VALUES.items())

def test_valid_values_on_postings(src_value, set_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25, {'expenseAllocation': src_value}),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert not errors

    assert txn.postings[-1].meta.get('expenseAllocation') == set_value

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_postings(src_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25, {'expenseAllocation': src_value}),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert errors

@pytest.mark.parametrize('src_value,set_value', VALID_VALUES.items())

def test_valid_values_on_transactions(src_value, set_value):

    txn = testutil.Transaction(expenseAllocation=src_value, postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert not errors

    assert txn.postings[-1].meta.get('expenseAllocation') == set_value

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_transactions(src_value):

    txn = testutil.Transaction(expenseAllocation=src_value, postings=[

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert errors

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

    'Accrued:AccountsReceivable',

    'Assets:Cash',

    'Income:Donations',

    'Liabilities:CreditCard',

    'UnearnedIncome:Donations',

])

def test_non_expense_accounts_skipped(account):

    txn = testutil.Transaction(postings=[

        (account, -25),

        ('Expenses:General', 25, {'expenseAllocation': 'program'}),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert not errors

@pytest.mark.parametrize('account,set_value', [

    ('Expenses:Services:Accounting', 'administration'),

    ('Expenses:Services:Administration', 'administration'),

    ('Expenses:Services:Advocacy', 'program'),

    ('Expenses:Services:Development', 'program'),

    ('Expenses:Services:Fundraising', 'fundraising'),

])

def test_default_values(account, set_value):

    txn = testutil.Transaction(postings=[

        ('Liabilites:CreditCard', -25),

        (account, 25),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert not errors

    assert txn.postings[-1].meta['expenseAllocation'] == set_value

@pytest.mark.parametrize('date,set_value', [

    (testutil.EXTREME_FUTURE_DATE, False),

    (testutil.FUTURE_DATE, True),

    (testutil.FY_START_DATE, True),

    (testutil.FY_MID_DATE, True),

    (testutil.PAST_DATE, False),

])

def test_default_value_set_in_date_range(date, set_value):

    txn = testutil.Transaction(date=date, postings=[

        ('Liabilites:CreditCard', -25),

        ('Expenses:General', 25),

    ])

    checker = meta_expense_allocation.MetaExpenseAllocation()

    assert not errors

    got_value = (txn.postings[-1].meta or {}).get('expenseAllocation')

    assert bool(got_value) == bool(set_value)

    'Refund': 'Refund',

    'Reimbursement': 'Reimbursement',

    'Retirement-Pretax': 'Retirement-Pretax',

    'Tax-Payment': 'Tax-Payment',

    'USA-501c3': 'USA-501c3',

    'USA-Corporation': 'USA-Corporation',

    'USA-LLC-No-1099': 'USA-LLC-No-1099',

    'W2': 'W2',

}

INVALID_VALUES = {

    '199',

    'W3',

    'Payrol',

    '',

}

@pytest.mark.parametrize('src_value,set_value', VALID_VALUES.items())

def test_valid_values_on_postings(src_value, set_value):

    txn = testutil.Transaction(postings=[

        ('Accrued:AccountsPayable', 25),

        ('Assets:Cash', -25, {'taxImplication': src_value}),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert not errors

    assert txn.postings[-1].meta.get('taxImplication') == set_value

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_postings(src_value):

    txn = testutil.Transaction(postings=[

        ('Accrued:AccountsPayable', 25),

        ('Assets:Cash', -25, {'taxImplication': src_value}),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert errors

@pytest.mark.parametrize('src_value,set_value', VALID_VALUES.items())

def test_valid_values_on_transactions(src_value, set_value):

    txn = testutil.Transaction(taxImplication=src_value, postings=[

        ('Accrued:AccountsPayable', 25),

        ('Assets:Cash', -25),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert not errors

    assert txn.postings[-1].meta.get('taxImplication') == set_value

@pytest.mark.parametrize('src_value', INVALID_VALUES)

def test_invalid_values_on_transactions(src_value):

    txn = testutil.Transaction(taxImplication=src_value, postings=[

        ('Accrued:AccountsPayable', 25),

        ('Assets:Cash', -25),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert errors

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

    'Accrued:AccountsPayable',

    'Expenses:General',

    'Liabilities:CreditCard',

])

def test_non_asset_accounts_skipped(account):

    txn = testutil.Transaction(postings=[

        (account, 25),

        ('Assets:Cash', -25, {'taxImplication': 'USA-Corporation'}),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert not errors

def test_asset_credits_skipped():

    txn = testutil.Transaction(postings=[

        ('Income:Donations', -25),

        ('Assets:Cash', 25),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert not errors

    assert not txn.postings[-1].meta

@pytest.mark.parametrize('date,need_value', [

    (testutil.EXTREME_FUTURE_DATE, False),

    (testutil.FUTURE_DATE, True),

    (testutil.FY_START_DATE, True),

    (testutil.FY_MID_DATE, True),

    (testutil.PAST_DATE, False),

])

def test_default_value_set_in_date_range(date, need_value):

    txn = testutil.Transaction(date=date, postings=[

        ('Liabilites:CreditCard', 25),

        ('Assets:Cash', -25),

    ])

    checker = meta_tax_implication.MetaTaxImplication()

    assert bool(errors) == bool(need_value)

# 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 pytest

from . import testutil

from conservancy_beancount import plugin

CONFIG_MAP = {}

HOOK_REGISTRY = plugin.HookRegistry()

@HOOK_REGISTRY.add_hook

class TransactionCounter:

    HOOK_GROUPS = frozenset(['Transaction', 'counter'])

    def run(self, txn):

        return ['txn:{}'.format(id(txn))]

@HOOK_REGISTRY.add_hook

class PostingCounter(TransactionCounter):

    HOOK_GROUPS = frozenset(['Posting', 'counter'])

        return ['post:{}'.format(id(post))]

def map_errors(errors):

    retval = {}

    for errkey in errors:

        key, _, errid = errkey.partition(':')

        retval.setdefault(key, set()).add(errid)

    return retval

def test_with_multiple_hooks():

    in_entries = [

        testutil.Transaction(postings=[

            ('Income:Donations', -25),

            ('Assets:Cash', 25),

        ]),

        testutil.Transaction(postings=[

            ('Expenses:General', 10),

            ('Liabilites:CreditCard', -10),

        ]),

    ]

    out_entries, errors = plugin.run(in_entries, CONFIG_MAP, '', HOOK_REGISTRY)

    assert len(out_entries) == 2

    errmap = map_errors(errors)

# 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 datetime

import beancount.core.amount as bc_amount

import beancount.core.data as bc_data

from decimal import Decimal

EXTREME_FUTURE_DATE = datetime.date(datetime.MAXYEAR, 12, 30)

FUTURE_DATE = datetime.date.today() + datetime.timedelta(days=365 * 99)

FY_START_DATE = datetime.date(2020, 3, 1)

FY_MID_DATE = datetime.date(2020, 9, 1)

PAST_DATE = datetime.date(2000, 1, 1)

def parse_date(s, fmt='%Y-%m-%d'):

    return datetime.datetime.strptime(s, fmt).date()

def Posting(account, number,

            currency='USD', cost=None, price=None, flag=None,

            **meta):

    return bc_data.Posting(

        account,

        bc_amount.Amount(Decimal(number), currency),

        cost,

        price,

        flag,

        meta,

    )

class Transaction:

    def __init__(self,

                 date=FY_MID_DATE, flag='*', payee=None,

                 narration='', tags=None, links=None, postings=None,

                 **meta):

        if isinstance(date, str):

            date = parse_date(date)

        self.date = date

        self.flag = flag

        self.payee = payee

        self.narration = narration

        self.tags = set(tags or '')

        self.links = set(links or '')

        self.postings = []

        self.meta = {