@classmethod

    def load_options_map(cls, options_map: OptionsMap) -> None:

        cls._options_map = options_map

        roots: Sequence[str] = bc_options.get_account_types(options_map)

        cls.ACCOUNT_RE = re.compile(

            r'^(?:{})(?:{}[A-Z0-9][-A-Za-z0-9]*)+$'.format(

                '|'.join(roots), cls.SEP,

            ))

    @classmethod

    def load_opening(cls, opening: Open) -> None:

        cls._meta_map[opening.account] = AccountMeta(opening)

    @classmethod

    def load_closing(cls, closing: Close) -> None:

        try:

            cls._meta_map[closing.account].add_closing(closing)

        except KeyError:

            raise ValueError(

                f"tried to load {closing.account} close directive before open",

            ) from None

    @classmethod

    def load_openings_and_closings(cls, entries: Iterable[Directive]) -> None:

        for entry in entries:

            # type ignores because Beancount's directives aren't type-checkable.

            if isinstance(entry, bc_data.Open):

                cls.load_opening(entry)  # type:ignore[arg-type]

            elif isinstance(entry, bc_data.Close):

                cls.load_closing(entry)  # type:ignore[arg-type]

    @classmethod

    def is_account(cls, s: str) -> bool:

        return cls.ACCOUNT_RE.fullmatch(s) is not None

    @property

    def meta(self) -> AccountMeta:

        return self._meta_map[self]

    def is_cash_equivalent(self) -> bool:

        return (

            self.is_under('Assets:') is not None

            and self.is_under('Assets:Prepaid', 'Assets:Receivable') is None

        )

    def is_checking(self) -> bool:

        return self.is_cash_equivalent() and ':Check' in self

    def is_credit_card(self) -> bool:

        return self.is_under('Liabilities:CreditCard') is not None

    def is_opening_equity(self) -> bool:

        return self.is_under('Equity:Funds', 'Equity:OpeningBalance') is not None

    def is_under(self, *acct_seq: str) -> Optional[str]:

        """Return a match if this account is "under" a part of the hierarchy

        Pass in any number of account name strings as arguments. If this

        account is under one of those strings in the account hierarchy, the

        first matching string will be returned. Otherwise, None is returned.

        You can use the return value of this method as a boolean if you don't

        care which account string is matched.

    'Equity:Funds:Restricted',

    'Expenses:Other',

    'Income:Donations',

    'Liabilities:CreditCard:Visa0123',

])

def test_is_account(clean_account_meta, account_s):

    assert data.Account.is_account(account_s)

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

    'Assets:checking',

    'Assets::Cash',

    'Equity',

    'Liabilities:Credit Card',

    'income:Donations',

    'Expenses:Banking_Fees',

    'Revenue:Grants',

])

def test_is_not_account(clean_account_meta, account_s):

    assert not data.Account.is_account(account_s)

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

    ('Revenue:Donations', True),

    ('Costs:Other', True),

    ('Income:Donations', False),

    ('Expenses:Other', False),

])

def test_is_account_respects_configured_roots(clean_account_meta, account_s, expected):

    config = bc_options.OPTIONS_DEFAULTS.copy()

    config['name_expenses'] = 'Costs'

    config['name_income'] = 'Revenue'

    data.Account.load_options_map(config)

    assert data.Account.is_account(account_s) == expected