if plugins is None:

            plugins = self.plugins

        years = iter(self.fiscal_year.range(from_fy, to_fy))

        try:

            books_start = self._format_include(next(years), 'books')

        except StopIteration:

            return ''

        return '\n'.join([

            *(self._format_plugin(name, opts) for name, opts in plugins.items()),

            books_start,

            *(self._format_include(year) for year in years),

        ])

    def load_fy_range(self,

                      from_fy: Year,

                      to_fy: Optional[Year]=None,

                      plugins: Optional[PluginsSpec]=None,

    ) -> LoadResult:

        """Load books for a range of fiscal years

        This is a convenience wrapper to call

        self.fy_range_string(from_fy, to_fy, plugins)

        and load the result with beancount.loader.load_string.

        """

            self.fy_range_string(from_fy, to_fy, plugins),

        )

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

            except AttributeError:

                pass

def balance_of(txn: Transaction,

               *preds: Callable[[Account], Optional[bool]],

) -> Amount:

    """Return the balance of specified postings in a transaction.

    Given a transaction and a series of account predicates, balance_of

    returns the balance of the amounts of all postings with accounts that

    match any of the predicates.

    balance_of uses the "weight" of each posting, so the return value will

    use the currency of the postings' cost when available.

    """

    match_posts = [post for post in Posting.from_txn(txn)

                   if any(pred(post.account) for pred in preds)]

    number = decimal.Decimal(0)

    if not match_posts:

        currency = ''

    else:

        weights: Sequence[Amount] = [

        ]

        number = sum((wt.number for wt in weights), number)

        currency = weights[0].currency

    return Amount(number, currency)

@functools.lru_cache()

def is_opening_balance_txn(txn: Transaction) -> bool:

    opening_equity = balance_of(txn, Account.is_opening_equity)

    if not opening_equity.currency:

        return False

    rest = balance_of(txn, lambda acct: not acct.is_opening_equity())

    if not rest.currency:

        return False

    return abs(opening_equity.number + rest.number) < decimal.Decimal('.01')

[aliases]

test=pytest

typecheck=pytest --addopts="--mypy conservancy_beancount"

[mypy]

disallow_any_unimported = True

disallow_untyped_defs = True

show_error_codes = True

strict_equality = True

warn_redundant_casts = True

warn_return_any = True

warn_unreachable = True

warn_unused_configs = True