runningtab 0.1.0.dev3__py3-none-any.whl

runningtab/coa.py

@@ -0,0 +1,212 @@
+"""What `runningtab coa` does between the prompts: plan, apply, prune, park.
+
+Everything here returns data or raises a typed error; `runningtab.cli` prints and
+picks exit codes. The rules that matter: a refused chart plan is never
+executed; a plan is re-made after the operator confirms and refused if it
+changed; prune only ever touches extras; parking (a renumber) is confined
+to `--allow-unapplied`.
+"""
+
+from __future__ import annotations
+
+import dataclasses
+
+from icedcoffee_sync.apply.diff import ChartPlan, Refusal, RefusalReason, diff
+from icedcoffee_sync.apply.execute import ApplyReport, apply_chart
+from icedcoffee_sync.apply.model import DesiredAccount, LiveAccount
+from icedcoffee_sync.apply.park import ParkedNumber, park_colliding_numbers, parking_candidates, unresolved_collisions
+from icedcoffee_sync.apply.prune import PrunePlan, PruneRefusal, PruneReport, execute_prune, plan_prune
+from icedcoffee_sync.erpnext.accounts import accounts_with_entries, company_abbr, document_name, read_chart
+from icedcoffee_sync.erpnext.company import clear_defaults_pointing_at, require_default_fields, set_default_accounts
+from icedcoffee_sync.frappe.client import Client, SiteConfig
+
+# Prune only touches extras, so a chart refusal blocks it only when it could
+# make the extras set wrong: ROOT_NOT_UNIQUE breaks the tree walk and
+# AMBIGUOUS_MATCH marks every candidate matched. The rest attach to a create
+# or a matched account. An explicit allow-list, so a new reason is classified
+# on purpose.
+PRUNE_BLOCKING_REFUSAL_REASONS = frozenset({RefusalReason.ROOT_NOT_UNIQUE, RefusalReason.AMBIGUOUS_MATCH})
+
+
+class NoSoleCompanyError(ValueError):
+    """The site has no company, or more than one, so `--company` is required."""
+
+
+class PlanChangedError(RuntimeError):
+    """The chart changed between the plan the operator confirmed and now."""
+
+
+@dataclasses.dataclass
+class Context:
+    """One planning pass against a site: the client, the chart, the live tree, the diff."""
+
+    client: Client
+    company: str
+    abbr: str
+    chart: list[DesiredAccount]
+    by_number: dict[str, DesiredAccount]
+    plan: ChartPlan
+    live: list[LiveAccount]
+    with_entries: set[str]
+    # The chart's Company default-account fields, as account numbers.
+    defaults: dict[str, str]
+
+
+def sole_company(client: Client) -> str:
+    """The site's only company; refuses to guess when there are none or several."""
+    # Two rows through iter_all, never one capped list call: a server-side
+    # page cap could make several companies look like one.
+    companies = client.iter_all("Company", fields=["name"])
+    first = next(companies, None)
+    if first is None:
+        raise NoSoleCompanyError("--company is required: this site has no companies")
+    second = next(companies, None)
+    if second is None:
+        return str(first["name"])
+    raise NoSoleCompanyError(
+        f"--company is required: this site has more than one company (at least {first['name']!r} and {second['name']!r})"
+    )
+
+
+def plan_against(
+    config: SiteConfig, company: str | None, chart: list[DesiredAccount], defaults: dict[str, str]
+) -> Context:
+    """Read the site and diff the chart against it.
+
+    `chart` and `defaults` are the caller's parse of `chart.coa`, never read
+    here: `period export` hands in its single snapshot, used for the
+    live-chart check, the package, and the manifest hash, and every other
+    caller reads the books directory's chart once and passes both halves.
+    """
+    client = Client(config)
+    resolved = company or sole_company(client)
+    live = read_chart(client, resolved)
+    with_entries = accounts_with_entries(client, [a.document_name for a in live])
+    return Context(
+        client=client,
+        company=resolved,
+        abbr=company_abbr(client, resolved),
+        chart=chart,
+        by_number={a.number: a for a in chart},
+        plan=diff(chart, live, with_entries),
+        live=live,
+        with_entries=with_entries,
+        defaults=dict(defaults),
+    )
+
+
+def blocking_prune_refusals(refusals: list[Refusal]) -> list[Refusal]:
+    """The chart refusals that make the extras set untrustworthy."""
+    return [refusal for refusal in refusals if refusal.reason in PRUNE_BLOCKING_REFUSAL_REASONS]
+
+
+def prune_plan_for(context: Context) -> PrunePlan:
+    """Which extras prune may delete, reusing the ledger probe the plan already paid for."""
+    extras = [extra.live for extra in context.plan.extras]
+    return plan_prune(extras, context.live, context.with_entries)
+
+
+def company_defaults(context: Context) -> dict[str, str]:
+    """Company default-account fields mapped to the chart accounts' document names."""
+    return {
+        field: document_name(context.by_number[number].name, context.abbr, number)
+        for field, number in context.defaults.items()
+    }
+
+
+@dataclasses.dataclass(frozen=True)
+class ApplyOutcome:
+    """What an apply did: the account changes (None when the plan was empty) and the defaults written."""
+
+    report: ApplyReport | None
+    defaults_written: list[str]
+
+
+def apply_confirmed(context: Context, fresh_plan: ChartPlan) -> ApplyOutcome:
+    """Execute a confirmed plan, after checking it still holds and the defaults can be set.
+
+    Raises `PlanChangedError` if `fresh_plan` differs from the confirmed one,
+    and `UnknownCompanyFieldError` before any account is touched if a
+    default field is not on this build's Company.
+    """
+    if fresh_plan != context.plan:
+        raise PlanChangedError("the chart plan changed since planning")
+    require_default_fields(context.client, context.company, context.defaults.keys())
+    report: ApplyReport | None = None
+    if not context.plan.is_empty:
+        report = apply_chart(
+            context.client, context.plan, context.live, context.by_number, context.abbr, context.company
+        )
+    # Always set the defaults: an applied chart with unset defaults is a
+    # half-configured ledger, and a rerun is how a failed default gets fixed.
+    written = set_default_accounts(context.client, context.company, company_defaults(context))
+    return ApplyOutcome(report=report, defaults_written=written)
+
+
+@dataclasses.dataclass(frozen=True)
+class ParkOutcome:
+    """Survivors renumbered, those skipped for gaining entries, and collisions left standing."""
+
+    gained_entries: list[str]
+    parked: list[ParkedNumber]
+    unresolved: list[str]
+
+
+def park_survivors(
+    client: Client,
+    extras: list[LiveAccount],
+    report: PruneReport,
+    refusals: list[PruneRefusal],
+    live: list[LiveAccount],
+    chart_numbers: frozenset[str],
+) -> ParkOutcome:
+    """Renumber surviving extras off the chart's numbers, never one carrying ledger entries."""
+    candidates, excluded = parking_candidates(extras, report, refusals)
+    gained: set[str] = set()
+    if candidates:
+        # Plan-time knowledge is stale by now: the prompt and the deletes
+        # both left time for an account to gain its first entry.
+        gained = accounts_with_entries(client, [a.document_name for a in candidates])
+        excluded = excluded + [a for a in candidates if a.document_name in gained]
+        candidates = [a for a in candidates if a.document_name not in gained]
+    taken = frozenset(a.number for a in live if a.number) | chart_numbers
+    parked = park_colliding_numbers(client, candidates, chart_numbers, taken)
+    return ParkOutcome(
+        gained_entries=sorted(gained),
+        parked=parked,
+        unresolved=unresolved_collisions(excluded, chart_numbers),
+    )
+
+
+@dataclasses.dataclass(frozen=True)
+class PruneOutcome:
+    """What a prune did, in the order it happened."""
+
+    cleared_defaults: list[str]
+    report: PruneReport
+    parking: ParkOutcome | None
+
+    @property
+    def failed(self) -> bool:
+        """True when a delete failed without being parked, or a collision is left standing."""
+        parked_names = {p.old_document_name for p in self.parking.parked} if self.parking else set()
+        unresolved = bool(self.parking and self.parking.unresolved)
+        return unresolved or any(name not in parked_names for name, _ in self.report.failed)
+
+
+def prune_confirmed(context: Context, prune_plan: PrunePlan, *, allow_unapplied: bool) -> PruneOutcome:
+    """Execute a confirmed prune plan; under `--allow-unapplied`, clear defaults first and park afterwards."""
+    cleared: list[str] = []
+    if allow_unapplied:
+        # ERPNext refuses to retire an account the Company record names as a
+        # default; apply repoints the defaults afterwards.
+        deleting = frozenset(d.live.document_name for d in prune_plan.deletes)
+        cleared = clear_defaults_pointing_at(context.client, context.company, deleting)
+    report = execute_prune(context.client, prune_plan)
+    parking: ParkOutcome | None = None
+    if allow_unapplied:
+        extras = [extra.live for extra in context.plan.extras]
+        parking = park_survivors(
+            context.client, extras, report, prune_plan.refusals, context.live, frozenset(context.by_number)
+        )
+    return PruneOutcome(cleared_defaults=cleared, report=report, parking=parking)

runningtab/doc.py

@@ -0,0 +1,185 @@
+"""Render a chart-of-accounts page's account tables from `chart.coa`.
+
+Two marker pairs are rewritten in place, nothing else is touched:
+`<!-- chart:table NUMBER -->` … `<!-- chart:end -->` (the subtree rooted at
+NUMBER, in file order) and `<!-- chart:defaults -->` … `<!-- chart:end -->`
+(the Company defaults). Tables are padded the way prettier pads them, so the
+pre-commit hook is a no-op on the output; if prettier disagrees, prettier wins.
+
+Which constrains the markdown a chart note may use: prettier rewrites
+`*italic*` to `_italic_`, so a note containing one renders, gets rewritten by
+the hook, and then fails `test_docs_chart_tables_are_generated` forever -- the
+generator keeps emitting what `chart.coa` says. Bold (`**`) and code spans
+survive untouched; use those.
+"""
+
+from __future__ import annotations
+
+import re
+
+from runningtab.chart import ChartDocument, ChartEntry, ChartError
+
+# Mostly a literal transcription of the [defaults] field name: replace `_`
+# with a space, capitalize the first letter. Three rows are not, because the
+# ERPNext field name does not describe the setting the way a person reading
+# the doc does:
+#
+# - default_expense_account: ERPNext's own field is named as a general
+#   "expense account" default, but the doc already calls out (in "Default
+#   accounts") that nothing else falls back to it -- it *is* the
+#   cost-of-goods-sold default, so the label says that instead.
+# - exchange_gain_loss_account: a literal transform gives "Exchange gain
+#   loss account"; the doc reads it as "gain / loss", matching how the pair
+#   is written everywhere else on the page (e.g. "Gain / Loss on Asset
+#   Disposal").
+# - disposal_account: the field name alone ("disposal account") does not say
+#   what kind of disposal event or what gets posted; the label spells out
+#   that this is the gain-or-loss side of an asset disposal.
+_DEFAULT_LABELS: dict[str, str] = {
+    "default_bank_account": "Default bank account",
+    "default_cash_account": "Default cash account",
+    "default_receivable_account": "Default receivable account",
+    "default_payable_account": "Default payable account",
+    "default_expense_account": "Default cost of goods sold account",
+    "default_income_account": "Default income account",
+    "round_off_account": "Round off account",
+    "exchange_gain_loss_account": "Exchange gain / loss account",
+    "write_off_account": "Write off account",
+    "default_deferred_revenue_account": "Default deferred revenue account",
+    "default_deferred_expense_account": "Default deferred expense account",
+    "accumulated_depreciation_account": "Accumulated depreciation account",
+    "depreciation_expense_account": "Depreciation expense account",
+    "disposal_account": "Gain / loss account on asset disposal",
+}
+
+_ACCOUNT_HEADERS = ["Number", "Account", "Type", "What goes here"]
+_DEFAULTS_HEADERS = ["Company setting", "Account"]
+
+_TABLE_RE = re.compile(r"chart:table\s+(\d+)")
+_DEFAULTS_RE = re.compile(r"chart:defaults")
+_END_RE = re.compile(r"chart:end")
+_ANY_MARKER_RE = re.compile(r"<!--\s*(chart:[a-z:0-9 ]*?)\s*-->")
+
+
+def _escape(cell: str) -> str:
+    """Escape a literal `|` so it cannot be read as a table column break."""
+    return cell.replace("|", "\\|")
+
+
+def _pad_table(headers: list[str], rows: list[list[str]]) -> str:
+    """A GFM pipe table, each column padded to its widest cell -- prettier's own rule.
+
+    Escapes every row cell before measuring or emitting it: `chart.coa`
+    permits a literal `|` in an account name just as freely as in a note,
+    and an unescaped one reads as a column break -- silently producing a
+    table row with an extra column instead of the cell text it was meant
+    to hold. Escaping here, once, centrally, means no future column ever
+    has to remember to call `_escape` itself.
+    """
+    escaped_rows = [[_escape(cell) for cell in row] for row in rows]
+    widths = [len(h) for h in headers]
+    for row in escaped_rows:
+        for i, cell in enumerate(row):
+            widths[i] = max(widths[i], len(cell))
+
+    def format_row(cells: list[str]) -> str:
+        return "| " + " | ".join(cell.ljust(width) for cell, width in zip(cells, widths, strict=True)) + " |"
+
+    lines = [format_row(headers), format_row(["-" * width for width in widths])]
+    lines.extend(format_row(row) for row in escaped_rows)
+    return "\n".join(lines) + "\n"
+
+
+def _children_by_parent(entries: list[ChartEntry]) -> dict[str | None, list[ChartEntry]]:
+    children: dict[str | None, list[ChartEntry]] = {}
+    for entry in entries:
+        children.setdefault(entry.account.parent_number, []).append(entry)
+    return children
+
+
+def _subtree(
+    number: str, by_number: dict[str, ChartEntry], children: dict[str | None, list[ChartEntry]]
+) -> list[ChartEntry]:
+    if number not in by_number:
+        raise ChartError(f"chart:table {number}: no account {number} in the chart")
+    ordered: list[ChartEntry] = []
+
+    def walk(current: str) -> None:
+        ordered.append(by_number[current])
+        for child in children.get(current, []):
+            walk(child.account.number)
+
+    walk(number)
+    return ordered
+
+
+def _render_account_table(entries: list[ChartEntry]) -> str:
+    rows = []
+    for entry in entries:
+        account = entry.account
+        type_cell = "Group" if account.is_group else (account.account_type or "")
+        rows.append([account.number, account.name, type_cell, entry.note])
+    return _pad_table(_ACCOUNT_HEADERS, rows)
+
+
+def _render_defaults_table(defaults: dict[str, str]) -> str:
+    rows = []
+    for field, number in defaults.items():
+        label = _DEFAULT_LABELS.get(field)
+        if label is None:
+            raise ChartError(f"chart:defaults: no doc label mapped for default field {field!r}")
+        rows.append([label, number])
+    return _pad_table(_DEFAULTS_HEADERS, rows)
+
+
+def render_doc(doc_text: str, chart: ChartDocument) -> str:
+    """Rewrite every marked table in `doc_text`, leaving everything else untouched.
+
+    Pure: takes the chart already parsed and the doc's current text, returns
+    the doc's new text. Raises `ChartError` if a marker is unknown,
+    unbalanced (a start with no `chart:end`, or a stray `chart:end`), or a
+    `chart:table` names a number absent from the chart.
+    """
+    by_number = {entry.account.number: entry for entry in chart.entries}
+    children = _children_by_parent(chart.entries)
+
+    lines = doc_text.splitlines(keepends=True)
+    out: list[str] = []
+    i = 0
+    while i < len(lines):
+        line = lines[i]
+        stripped = line.strip()
+
+        if _END_RE.search(stripped):
+            raise ChartError(f"line {i + 1}: 'chart:end' with no matching start marker")
+
+        table_match = _TABLE_RE.search(stripped)
+        is_defaults = _DEFAULTS_RE.search(stripped) is not None
+        if not table_match and not is_defaults:
+            unknown = _ANY_MARKER_RE.search(stripped)
+            if unknown:
+                raise ChartError(f"line {i + 1}: unknown marker {unknown.group(1)!r}")
+            out.append(line)
+            i += 1
+            continue
+
+        out.append(line)  # the start marker itself, verbatim
+        start_line = i
+        i += 1
+        while i < len(lines) and not _END_RE.search(lines[i].strip()):
+            i += 1
+        if i >= len(lines):
+            raise ChartError(f"line {start_line + 1}: {stripped!r} has no matching 'chart:end'")
+
+        rendered = (
+            _render_account_table(_subtree(table_match.group(1), by_number, children))
+            if table_match
+            else _render_defaults_table(chart.defaults)
+        )
+        out.append("\n")
+        out.append(rendered)
+        out.append("\n")
+        out.append(lines[i])  # the end marker itself, verbatim
+        i += 1
+
+    return "".join(out)

runningtab/forecast/__init__.py

@@ -0,0 +1 @@
+"""The capital forecast: what the members must put in over the coming months."""

runningtab/forecast/compute.py

@@ -0,0 +1,224 @@
+"""The capital call: how much each member must put in over the next three months.
+
+Pure arithmetic over the forecast file, the bank's opening balance and this
+month's Mercury transactions. Nothing here reads a clock or a network, so the
+same inputs always produce the same answer.
+
+The answer is money people will pay, so every choice errs toward asking for
+enough: a line costs its `high` amount, a charge not yet seen in the bank is
+still owed, and each member's share rounds up to the cent.
+"""
+
+from __future__ import annotations
+
+import calendar
+import dataclasses
+import datetime as dt
+from collections.abc import Iterable
+from decimal import ROUND_CEILING, Decimal
+from typing import Literal
+
+from runningtab.forecast.model import ForecastFile, Line
+from runningtab.mercury.models import Transaction
+
+SCENARIO = "conservative"
+FIXED_FLOOR_SOURCE = "[call] floor"
+NO_FLOOR_SOURCE = "no owed charges"
+_CENT = Decimal("0.01")
+_FULL_MONTHS_AHEAD = 3
+# A charge settles a due only within this band around the line's range. Usage
+# bills drift a little from the estimate, but a charge far outside it is a
+# different bill from the same vendor, and counting it as this one would leave
+# the real bill uncounted and the call understated.
+_SETTLE_BELOW = Decimal("0.9")
+_SETTLE_ABOVE = Decimal("1.1")
+
+
+@dataclasses.dataclass(frozen=True)
+class Due:
+    """One occurrence of a line, at the amount we plan for (its `high`)."""
+
+    line: Line
+    due: dt.date
+    amount: Decimal
+    status: Literal["owed", "seen paid"]
+
+
+@dataclasses.dataclass(frozen=True)
+class Month:
+    """One month of the cash path. `month` is its first day."""
+
+    month: dt.date
+    opening: Decimal
+    outflows: Decimal
+    inflows: Decimal
+    closing: Decimal
+
+
+@dataclasses.dataclass(frozen=True)
+class Forecast:
+    """The whole answer, with what it was computed from."""
+
+    computed_at: dt.datetime
+    ledger_through: dt.date
+    window_start: dt.date
+    window_end: dt.date
+    scenario: str
+    opening_cash: Decimal
+    floor: Decimal
+    floor_from: str
+    months: tuple[Month, ...]
+    dues: tuple[Due, ...]
+    members: tuple[tuple[str, Decimal], ...]
+    total_call: Decimal
+
+
+def _month_end(year: int, month: int) -> dt.date:
+    return dt.date(year, month, calendar.monthrange(year, month)[1])
+
+
+def _add_months(first: dt.date, n: int) -> dt.date:
+    index = first.year * 12 + first.month - 1 + n
+    return dt.date(index // 12, index % 12 + 1, 1)
+
+
+def window(today: dt.date) -> tuple[dt.date, dt.date]:
+    """From today through the end of the third full month after this one."""
+    last = _add_months(today.replace(day=1), _FULL_MONTHS_AHEAD)
+    return today, _month_end(last.year, last.month)
+
+
+def _occurrences(line: Line, first: dt.date, end: dt.date) -> Iterable[dt.date]:
+    """Every date the line falls due between the first of the current month and `end`."""
+    if line.cadence == "monthly":
+        if line.day is None:
+            raise ValueError(f"monthly line {line.name!r} has no day")
+        month = first
+        while month <= end:
+            # Day 31 falls on the last day of a shorter month.
+            day = min(line.day, calendar.monthrange(month.year, month.month)[1])
+            yield month.replace(day=day)
+            month = _add_months(month, 1)
+    elif line.cadence == "yearly":
+        if line.on is None:
+            raise ValueError(f"yearly line {line.name!r} has no date")
+        for year in range(first.year, end.year + 1):
+            yield line.on.replace(year=year)
+    else:
+        raise ValueError(f"line {line.name!r} has unknown cadence {line.cadence!r}")
+
+
+def _payments(transactions: Iterable[Transaction], today: dt.date) -> list[Transaction]:
+    """Charges we paid this month, up to today, in money the opening balance already reflects."""
+    return [
+        t
+        for t in transactions
+        if t.counterparty_name
+        and t.amount < 0
+        and t.counts_toward_balance
+        and (t.accounting_date.year, t.accounting_date.month) == (today.year, today.month)
+        and t.accounting_date <= today
+    ]
+
+
+def _dues(file: ForecastFile, today: dt.date, end: dt.date, payments: list[Transaction]) -> tuple[Due, ...]:
+    """Every due in the window, each marked `seen paid` only if a payment of its own settles it.
+
+    One bank charge pays at most one due: two lines can share a counterparty
+    ("Google"), and a single charge must not mark both paid. Dues are settled
+    by pairing every eligible payment with the due it is nearest in price to
+    (earlier due date, then file order, break ties); each payment and each due
+    is used once. A payment is eligible for a due when its counterparty matches
+    and its amount is within the tolerance band of the line's range. A due left
+    without a payment stays owed.
+    """
+    first = today.replace(day=1)
+    found: list[tuple[dt.date, int, Line]] = []
+    for index, line in enumerate(file.lines):
+        for due in _occurrences(line, first, end):
+            if not first <= due <= end:
+                continue
+            if (line.starts and due < line.starts) or (line.ends and due > line.ends):
+                continue
+            found.append((due, index, line))
+    found.sort(key=lambda f: (f[0], f[1]))
+
+    # Every way a payment could settle a due, nearest-priced first.
+    pairs = sorted(
+        (abs(abs(t.amount) - line.amount.high), due, index, p, f)
+        for f, (due, index, line) in enumerate(found)
+        if due < today
+        for p, t in enumerate(payments)
+        if (t.counterparty_name or "").casefold() in {m.casefold() for m in line.match}
+        and line.amount.low * _SETTLE_BELOW <= abs(t.amount) <= line.amount.high * _SETTLE_ABOVE
+    )
+    settled: set[int] = set()
+    used: set[int] = set()
+    for _, _, _, p, f in pairs:
+        if p not in used and f not in settled:
+            used.add(p)
+            settled.add(f)
+
+    dues = [
+        Due(line, due, line.amount.high, "seen paid" if f in settled else "owed")
+        for f, (due, _, line) in enumerate(found)
+    ]
+    return tuple(sorted(dues, key=lambda d: (d.due, d.line.name)))
+
+
+def compute(
+    file: ForecastFile,
+    *,
+    now: dt.datetime,
+    opening_cash: Decimal,
+    ledger_through: dt.date,
+    transactions: Iterable[Transaction],
+) -> Forecast:
+    """The capital each member must contribute to keep cash at or above the floor.
+
+    The floor is the largest single charge, so a one-off bill is always
+    coverable. The call is whatever lifts the cash path's lowest closing
+    balance to the floor, `max(0, floor - lowest closing)`, split evenly and
+    rounded up per member.
+    """
+    today = now.date()
+    start, end = window(today)
+    dues = _dues(file, today, end, _payments(transactions, today))
+    owed = [d for d in dues if d.status == "owed"]
+
+    months: list[Month] = []
+    opening = opening_cash
+    month = start.replace(day=1)
+    while month <= end:
+        outflows = sum((d.amount for d in owed if (d.due.year, d.due.month) == (month.year, month.month)), Decimal(0))
+        inflows = Decimal(0)
+        closing = opening + inflows - outflows
+        months.append(Month(month, opening, outflows, inflows, closing))
+        opening = closing
+        month = _add_months(month, 1)
+
+    if file.call.floor is not None:
+        floor, floor_from = file.call.floor, FIXED_FLOOR_SOURCE
+    elif owed:
+        biggest = max(owed, key=lambda d: d.amount)
+        floor, floor_from = biggest.amount, biggest.line.name
+    else:
+        floor, floor_from = Decimal(0), NO_FLOOR_SOURCE
+
+    call = max(Decimal(0), floor - min(m.closing for m in months))
+    share = (call / len(file.call.members)).quantize(_CENT, rounding=ROUND_CEILING)
+    members = tuple((m, share) for m in file.call.members)
+    return Forecast(
+        computed_at=now,
+        ledger_through=ledger_through,
+        window_start=start,
+        window_end=end,
+        scenario=SCENARIO,
+        opening_cash=opening_cash,
+        floor=floor,
+        floor_from=floor_from,
+        months=tuple(months),
+        dues=dues,
+        members=members,
+        total_call=sum((s for _, s in members), Decimal(0)),
+    )