Open,

    OptionsMap,

    Posting as BasePosting,

    Transaction,

)

DecimalCompat = Union[decimal.Decimal, int]

LINK_METADATA = frozenset([

    'approval',

    'bank-statement',

    'check',

    'contract',

    'invoice',

    'purchase-order',

    'receipt',

from . import core

from . import rewrite

from .. import books

from .. import cliutil

from .. import config as configmod

from .. import data

from .. import ranges

PROGNAME = 'balance-sheet-report'

logger = logging.getLogger('conservancy_beancount.reports.balance_sheet')

KWArgs = Mapping[str, Any]

class Fund(enum.IntFlag):

    RESTRICTED = enum.auto()

    UNRESTRICTED = enum.auto()

                retval += balance

        return retval

    def classifications(self,

                        account: str,

                        sort_period: Optional[int]=None,

    ) -> Sequence[data.Account]:

        if sort_period is None:

                sort_period = Period.PERIOD

            else:

                sort_period = Period.ANY

        class_bals: Mapping[data.Account, core.MutableBalance] \

            = collections.defaultdict(core.MutableBalance)

        for key, balance in self.balances.items():

            if not key.account.is_under(account):

                pass

        equity_totals = [core.MutableBalance() for _ in balance_kwargs]

        self.add_row(self.string_cell("Net Assets", stylename=self.style_bold))

        self.add_row()

        for fund in [Fund.UNRESTRICTED, Fund.RESTRICTED]:

            preposition = "Without" if fund is Fund.UNRESTRICTED else "With"

            row = self.add_row(self.string_cell(f"{preposition} donor restrictions"))

            for kwargs, total_bal in zip(balance_kwargs, equity_totals):

                row.addElement(self.balance_cell(balance))

                total_bal += balance

        self.write_totals_row(

            "Total Net Assets", equity_totals, stylename=self.style_total,

        )

        self.write_totals_row(

            "Total Liabilities and Net Assets",

            liabilities, equity_totals,

        self.write_totals_row("Change in Net Assets", income_totals, other_totals)

        for kwargs in bal_kwargs:

            if kwargs['period'] is Period.PERIOD:

                kwargs['period'] = Period.THRU_MIDDLE

            else:

                kwargs['period'] = Period.OPENING

        equity_totals = [

            for kwargs in bal_kwargs

        ]

        self.write_totals_row("Beginning Net Assets", equity_totals)

        self.write_totals_row(

            "Ending Net Assets",

            income_totals, other_totals, equity_totals,

            stylename=self.style_bottomline,

        )

        ]

        norm_func = operator.neg

        self.add_row(self.string_cell(

            "Cash Flows from Operating Activities",

            stylename=self.style_bold,

        ))

        equity_totals = [

            for kwargs in bal_kwargs

        ]

        self.write_totals_row("Change in Net Assets", equity_totals, leading_rows=1)

        self.add_row(self.string_cell(

            "(Increase) decrease in operating assets:",

        ))

        asset_totals = self.write_classifications_by_account(

            'Assets', bal_kwargs, (self.C_CASH,), self.SPACE, norm_func,

        header_row.removeChild(header_row.firstChild)

        header_row.insertBefore(self.multiline_cell(

            ["Balance Ending", self.period_name],

            stylename=header_row.lastChild.getAttribute('stylename'),

        ), header_row.lastChild)

        for acct_root in ['Assets', 'Liabilities', 'Income', 'Expenses', 'Equity']:

            norm_func = core.normalize_amount_func(f'{acct_root}:Dummy')

            self.add_row()

            for account in self.balances.iter_accounts(acct_root):

                period_bal = self.balances.total(

                    account=account, period=Period.PERIOD, account_exact=True,

                )

                prior_bal = self.balances.total(

                    account=account, period=Period.PRIOR, account_exact=True,

                )

from beancount.core import data as bc_data

from beancount.core import display_context as bc_dcontext

from beancount.parser import printer as bc_printer

from beancount.core.convert import get_cost

from beancount.core.inventory import Inventory

from beancount.core.position import Position, get_position

RESTRICTED_ACCOUNT = data.Account('Equity:Funds:Restricted')

UNRESTRICTED_ACCOUNT = data.Account('Equity:Funds:Unrestricted')

PROGNAME = 'opening-balances'

logger = logging.getLogger('conservancy_beancount.tools.opening_balances')

def quantize_amount(

        amount: data.Amount,

        exp: Decimal=Decimal('.01'),

    for error in load_errors:

        bc_printer.print_error(error, file=stderr)

    inventories: Mapping[AccountWithFund, Inventory] = collections.defaultdict(Inventory)

    for post in Posting.from_entries(entries):

        if post.meta.date >= args.as_of_date:

            continue

        account = post.account

        if fund_acct_match is None:

            project: MetaValue = None

        else:

            project = post.meta.get(args.meta_key)

            if project is None:

                bc_printer.print_error(Error(

                    post.meta, "no fund specified", post.meta.txn,

                ), file=stderr)