Iter = Iterable[Error]

class BrokenLinkError(Error):

    def __init__(self, txn, key, link, source=None):

        super().__init__(

            "{} not found in repository: {}".format(key, link),

            txn,

            source,

        )

class BrokenRTLinkError(Error):

    def __init__(self, txn, key, link, parsed=True, source=None):

        if parsed:

            msg_fmt = "{} not found in RT: {}"

        else:

            msg_fmt = "{} link is malformed: {}"

        super().__init__(

            msg_fmt.format(key, link),

            txn,

            source,

        )

class ConfigurationError(Error):

    def __init__(self, message, entry=None, source=None):

        if source is None:

            source = {}

        self._fill_source(source)

        super().__init__(message, entry, source)

class InvalidMetadataError(Error):

        if post is None:

            srcname = 'transaction'

        else:

            srcname = post.account

        if value is None:

        else:

        return txn.date in self.TXN_DATE_RANGE

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

class _NormalizePostingMetadataHook(_PostingHook):

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

    # This class provides basic functionality to filter postings, normalize

    # metadata values, and set default values.

    METADATA_KEY: MetaKey

    VALUES_ENUM: MetadataEnum

    def __init_subclass__(cls) -> None:

        super().__init_subclass__()

        cls.METADATA_KEY = cls.VALUES_ENUM.key

        cls.HOOK_GROUPS = cls.HOOK_GROUPS.union(['metadata', cls.METADATA_KEY])

    # 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: Transaction, post: data.Posting) -> MetaValueEnum:

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

        source_value = post.meta.get(self.METADATA_KEY)

        set_value = source_value

        error: Optional[errormod.Error] = None

        if source_value is None:

            try:

                set_value = self._default_value(txn, post)

            except errormod.Error as error_:

                error = error_

        else:

            try:

                set_value = self.VALUES_ENUM[source_value]

            except KeyError:

                error = errormod.InvalidMetadataError(

                )

        if error is None:

            post.meta[self.METADATA_KEY] = set_value

        else:

            yield error

#

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

from . import core

from .. import data

from .. import errors as errormod

from ..beancount_types import (

    Transaction,

)

class MetaEntity(core.TransactionHook):

    METADATA_KEY = 'entity'

    HOOK_GROUPS = frozenset(['posting', 'metadata', METADATA_KEY])

    ENTITY_RE = re.compile(r'^[A-Za-z0-9]+(?:-[A-Za-z0-9]+)*$')

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

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

        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:

        for post in data.iter_postings(txn):

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

                continue

            entity = post.meta.get(self.METADATA_KEY)

            if entity is None:

            elif entity is txn_entity:

                pass

            elif not self.ENTITY_RE.match(entity):

from ..beancount_types import (

    MetaValueEnum,

    Transaction,

)

class MetaIncomeType(core._NormalizePostingMetadataHook):

    VALUES_ENUM = core.MetadataEnum('income-type', {

        'Donations',

        'Payable-Derecognition',

        'RBI',

        'UBTI',

    })

    DEFAULT_VALUES = {

        'Income:Donations': 'Donations',

        'Income:Honoraria': 'RBI',

        'Income:Interest': 'RBI',

        'Income:Interest:Dividend': 'RBI',

        'Income:Royalties': 'RBI',

        'Income:Sales': 'RBI',

        'Income:SoftwareDevelopment': 'RBI',

        'Income:TrademarkLicensing': 'RBI',

        'UnearnedIncome:Conferences:Registrations': 'RBI',

        'UnearnedIncome:MatchPledges': 'Donations',

    }

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

        return post.account.is_income()

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

        try:

            return self.DEFAULT_VALUES[post.account]

        except KeyError:

                if name != human_name:

                    aliases[human_name] = name

                if name != key:

                    aliases[key] = name

        except AttributeError:

            self._config_error("loaded YAML data not in project-data format", project_data_path)

        except OSError as error:

            self._config_error(error.strerror, project_data_path)

        except yaml.error.YAMLError as error:

            self._config_error(error.args[0] or "YAML load error", project_data_path)

        else:

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

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

        source = {}

        if filename is not None:

            source['filename'] = str(filename)

        raise errormod.ConfigurationError(

            "cannot load project data: " + msg,

            source=source,

        )

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

        return post.account.is_under('Assets', 'Liabilities') is None

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

        if post.account.is_under(

                'Accrued:VacationPayable',

                'Expenses:Payroll',

        ):

            return self.DEFAULT_PROJECT

        else:

    '-foo',

    'foo-',

    '-',

    'Überentity',

    'Alex Smith',

    ' ',

    '',

}

TEST_KEY = 'entity'

@pytest.fixture(scope='module')

def hook():

    config = testutil.TestConfig()

    return meta_entity.MetaEntity(config)

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

def test_valid_values_on_postings(hook, src_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

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

    ])

    assert not any(hook.run(txn))

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

def test_invalid_values_on_postings(hook, src_value):

    txn = testutil.Transaction(postings=[

        ('Assets:Cash', -25),

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

    ])

    errors = list(hook.run(txn))

    assert len(errors) == 1

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

def test_valid_values_on_transactions(hook, src_value):

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

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    assert not any(hook.run(txn))

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

def test_invalid_values_on_transactions(hook, src_value):

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

        ('Assets:Cash', -25),

        ('Expenses:General', 25),

    ])

    errors = list(hook.run(txn))

    assert 1 <= len(errors) <= 2

               for error in hook.run(txn))

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

    ('Accrued:AccountsReceivable', True),

    ('Assets:Cash', False),

    ('Expenses:General', True),

    ('Income:Donations', True),

    ('Liabilities:CreditCard', False),

    ('UnearnedIncome:Donations', True),

])

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)