return cls(

            Account(post.account),

            *post[1:5],

            # see rationale above about Posting.meta

            PostingMeta(txn, index, post), # type:ignore[arg-type]

        )

    @classmethod

        """Yield an enhanced Posting object for every posting in the transaction"""

        for index, post in enumerate(txn.postings):

            yield cls.from_beancount(txn, index, post)

    @classmethod

        """Yield an enhanced Posting object for every posting in these entries"""

        for entry in entries:

            # Because Beancount's own Transaction class isn't type-checkable,

            # we can't statically check this. Might as well rely on duck

            # typing while we're at it: just try to yield postings from

            # everything, and ignore entries that lack a postings attribute.

            try:

                yield from cls.from_txn(entry)  # type:ignore[arg-type]

import importlib

import beancount.core.data as bc_data

from typing import (

    AbstractSet,

    Any,

    Dict,

    List,

    Optional,

    Set,

    Tuple,

    Type,

)

from ..beancount_types import (

    ALL_DIRECTIVES,

        module = importlib.import_module(mod_name, package)

        for hook_name in hook_names:

            self.add_hook(getattr(module, hook_name))

    def load_included_hooks(self) -> None:

        for mod_name, hook_names in self.INCLUDED_HOOKS.items():

            self.import_hooks(mod_name, *(hook_names or []), package=self.__module__)

        config_str = config_str.strip()

        if not config_str:

            config_str = 'all'

        elif config_str.startswith('-'):

            config_str = 'all ' + config_str

        available_hooks: Set[Type[Hook]] = set()

        for token in config_str.split():

            if token.startswith('-'):

    def __init_subclass__(cls) -> None:

        super().__init_subclass__()

        cls.HOOK_GROUPS = cls.HOOK_GROUPS.union(cls.CHECKED_METADATA).union('metadata')

    def _check_metadata(self,

                        txn: Transaction,

                        post: data.Posting,

                        keys: Sequence[MetaKey],

        have_docs = False

        for key in keys:

            try:

                links = post.meta.get_links(key)

            except TypeError as error:

                yield errormod.InvalidMetadataError(txn, key, post.meta[key], post)

            else:

                have_docs = have_docs or any(links)

        return len(self._postings)

    def add(self, post: data.Posting) -> None:

        self._postings.append(post)

    def clear(self) -> None:

        self._postings.clear()

        balance = MutableBalance()

        for post in self:

            balance.add_amount(post.units)

            yield post, balance

    def balance(self) -> Balance:

        for _, balance in self.iter_with_balance():

            pass