return self[default_key]

### HOOK SUBCLASSES

class _PostingHook(TransactionHook, metaclass=abc.ABCMeta):

    TXN_DATE_RANGE: _GenericRange = _GenericRange(DEFAULT_START_DATE, DEFAULT_STOP_DATE)

    def __init_subclass__(cls) -> None:

        cls.HOOK_GROUPS = cls.HOOK_GROUPS.union(['posting'])

    def _run_on_txn(self, txn: Transaction) -> bool:

    def _run_on_post(self, txn: Transaction, post: data.Posting) -> bool:

        return True

    def run(self, txn: Transaction) -> errormod.Iter:

        if self._run_on_txn(txn):

            for post in data.iter_postings(txn):

                if self._run_on_post(txn, post):

                    yield from self.post_run(txn, post)

    @abc.abstractmethod

    def post_run(self, txn: Transaction, post: data.Posting) -> errormod.Iter: ...

    # letters and digits, minus the Latin 1 supplement (i.e., Roman letters

    # with diacritics: áÁàÀâÂåÅäÄãà çÇ ðÐ ñÑ øØ ß etc.)

    # See the tests for specific cases.

    alnum = r'\p{Letter}\p{Digit}--\p{Block=Latin_1_Supplement}'

    # A regexp that would be reasonably stricter would be:

    #   f'^[{alnum}][.{alnum}]*(?:-[.{alnum}])*$'

    # However, current producers fail that regexp in a few different ways.

    # See the tests for specific cases.

    ENTITY_RE: Pattern[str] = regex.compile(f'^[{alnum}][-.{alnum}]*$', regex.VERSION1)

    del alnum

    def run(self, txn: Transaction) -> errormod.Iter:

        txn_entity = txn.meta.get(self.METADATA_KEY, txn.payee)

        if txn_entity is None:

            txn_entity_ok = None

        elif isinstance(txn_entity, str):

            txn_entity_ok = bool(self.ENTITY_RE.match(txn_entity))

        else:

            txn_entity_ok = False

        if txn_entity_ok is False:

            yield errormod.InvalidMetadataError(txn, self.METADATA_KEY, txn_entity)

        for post in data.iter_postings(txn):

            if not post.account.is_under(

                    'Assets:Receivable',

from typing import (

    Any,

    Dict,

    NoReturn,

    Optional,

    Set,

)

class MetaProject(core._NormalizePostingMetadataHook):

    DEFAULT_PROJECT = 'Conservancy'

    PROJECT_DATA_PATH = Path('Projects', 'project-data.yml')

    VALUES_ENUM = core.MetadataEnum('project', {DEFAULT_PROJECT})

    def __init__(self, config: configmod.Config, source_path: Path=PROJECT_DATA_PATH) -> None:

        repo_path = config.repository_path()

        if repo_path is None:

            self._config_error("no repository configured")

        project_data_path = repo_path / source_path

        source = {'filename': str(project_data_path)}

        try:

            with project_data_path.open() as yaml_file:

                project_data: Dict[str, Dict[str, Any]] = yaml.safe_load(yaml_file)

            names: Set[MetaValueEnum] = {self.DEFAULT_PROJECT}

            aliases: Dict[MetaValueEnum, MetaValueEnum] = {}

        else:

            self.VALUES_ENUM = core.MetadataEnum(self.METADATA_KEY, names, aliases)

    def _config_error(self, msg: str, filename: Optional[Path]=None) -> NoReturn:

        source = {}

        if filename is not None:

            source['filename'] = str(filename)

        raise errormod.ConfigurationError(

            "cannot load project data: " + msg,

            source=source,

        )

        if post.account.is_under('Liabilities'):

            return not post.account.is_credit_card()

        else:

            return post.account.is_under(

                'Assets:Receivable',

                'Expenses',

                'Income',

            ) is not None

    def _default_value(self, txn: Transaction, post: data.Posting) -> MetaValueEnum:

        if post.account.is_under(

                'Expenses:Payroll',

                'Liabilities:Payable:Vacation',

        ):

            return self.DEFAULT_PROJECT

        else:

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

def test_which_accounts_required_on(hook, account, required):

    txn = testutil.Transaction(postings=[

        ('Assets:Checking', -25),

        (account, 25),

    ])

    errors = list(hook.run(txn))

    if not required:

        assert not errors

    else:

        assert errors

        assert any(error.message == "{} missing entity".format(account)

                   for error in errors)

from conservancy_beancount.plugin import meta_invoice

REQUIRED_ACCOUNTS = {

    'Assets:Receivable:Accounts',

    'Assets:Receivable:Loans',

    'Liabilities:Payable:Accounts',

    'Liabilities:Payable:Vacation',

}

NON_REQUIRED_ACCOUNTS = {

    'Assets:Cash',

    'Expenses:Other',

    'Income:Other',

    'Liabilities:CreditCard',

}

TEST_KEY = 'invoice'

MISSING_MSG = f'{{}} missing {TEST_KEY}'.format

WRONG_TYPE_MSG = f'{{}} has wrong type of {TEST_KEY}: expected str but is a {{}}'.format

@pytest.fixture(scope='module')

def hook():

@pytest.mark.parametrize('acct1,acct2', testutil.combine_values(

    REQUIRED_ACCOUNTS,

    NON_REQUIRED_ACCOUNTS,

))

def test_missing_invoice(hook, acct1, acct2):

    txn = testutil.Transaction(postings=[

        (acct2, -25),

        (acct1, 25),

    ])

    actual = {error.message for error in hook.run(txn)}

    assert actual == {"{} missing {}".format(acct1, TEST_KEY)}

    'Assets:Cash',

    'Assets:Receivable:Accounts',

    'Equity:OpeningBalance',

    'Expenses:BankingFees',

    'Income:Donations',

    'Liabilities:CreditCard',

    'Liabilities:Payable:Vacation',

    'Liabilities:UnearnedIncome:Donations',

])

def test_does_not_apply_to_other_accounts(hook, account):

    meta = seed_meta()

    check(hook, None, account, post_meta=meta)

@pytest.mark.parametrize('txn_id,inv_id', testutil.combine_values(

    VALID_TXN_IDS,

    VALID_INVOICE_IDS,

))

def test_invoice_payment_transaction_ok(hook, txn_id, inv_id):

    txn = testutil.Transaction(**{TEST_KEY: txn_id}, postings=[

        ('Assets:Receivable:Accounts', -100, {TEST_KEY: inv_id}),

        ('Assets:PayPal', 97),

        ('Expenses:BankingFees', 3),

    ])

    assert not list(hook.run(txn))

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    errors = list(hook.run(txn))

    assert errors

    testutil.check_post_meta(txn, None, None)

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

    ('Assets:Cash', False),

    ('Assets:Receivable:Accounts', True),

    ('Assets:Receivable:Loans', True),

    ('Equity:OpeningBalance', False),

    ('Expenses:General', True),

    ('Income:Donations', True),

    ('Liabilities:CreditCard', False),

    ('Liabilities:Payable:Accounts', True),

    # We do want a "project" for Lia:Pay:Vacation but it has a default value

    ('Liabilities:Payable:Vacation', False),

    ('Liabilities:UnearnedIncome:Donations', True),

])

def test_which_accounts_required_on(hook, account, required):

    txn = testutil.Transaction(postings=[

        ('Assets:Checking', 25),

        (account, 25),

    config = testutil.TestConfig(repo_path=repo_path)

    with pytest.raises(errormod.ConfigurationError):

        meta_project.MetaProject(config)

@pytest.mark.parametrize('repo_path_s,data_path_s', [

    ('repository', 'Projects/project-list.yml'),

    ('..', 'LICENSE.txt'),

])

def test_invalid_project_data(repo_path_s, data_path_s):

    config = testutil.TestConfig(repo_path=repo_path_s)

    with pytest.raises(errormod.ConfigurationError):

        meta_project.MetaProject(config, Path(data_path_s))

# These are mostly fill-in values.

# We don't need to run every test on every value for these, just enough to

# convince ourselves the hook never reports errors against these accounts.

# Making this a iterator rather than a sequence means testutil.combine_values

# doesn't require the decorated test to go over every value, which in turn

# trims unnecessary test time.

NOT_REQUIRED_ACCOUNTS = itertools.cycle([

    # Only paypal-id is required for PayPal transactions

    'Assets:PayPal',

    'Assets:Prepaid:Expenses',

    'Assets:Receivable:Accounts',

    'Expenses:Other',

    'Income:Other',

    'Liabilities:Payable:Accounts',

    'Liabilities:UnearnedIncome:Donations',

])

CHECK_IDS = (decimal.Decimal(n) for n in itertools.count(1))

def BAD_CHECK_IDS():

    # Valid check-id values are positive integers

    yield decimal.Decimal(0)

    yield -next(CHECK_IDS)

    yield next(CHECK_IDS) * decimal.Decimal('1.1')

    testutil.LINK_METADATA_STRINGS,

))

def test_fallback_on_zero_amount_postings(hook, test_acct, other_acct, value):

    # Unfortunately it does happen that we get donations that go 100% to

    # banking fees, and our importer writes a zero-amount posting to the

    # Assets account.

    txn = testutil.Transaction(postings=[

        ('Income:Donations', '-.1'),

        ('Expenses:BankingFees', '.1'),

        (test_acct.name, 0, {test_acct.fallback_meta: value}),

    ])

    assert not list(hook.run(txn))

    'Expenses:BankingFees',

    'Liabilities:CreditCard',

    'Liabilities:Payable:Accounts',

])

def test_does_not_apply_to_other_accounts(hook, account):

    meta = seed_meta()

    check(hook, None, account, 'Expenses:Other', post_meta=meta)

def test_configuration_error_without_rt():

    config = testutil.TestConfig()

    with pytest.raises(errormod.ConfigurationError):

        meta_receivable_documentation.MetaReceivableDocumentation(config)