NPO-Accounting/conservancy_beancount Changeset - 7441f4ef0ce1

Changeset - 7441f4ef0ce1

Parent rev.

Child rev.

[Not reviewed]

0 3 0

Brett Smith - 4 years ago 2020-06-17 22:25:47
brettcsmith@brettcsmith.org

ledger: Correct period totals. RT#11661.

The period totals were reporting the balance of all the loaded postings, not
just the ones in the reporting date range.

Like the accrual report, introduce a RelatedPostings subclass that records
and saves all the information we need at group definition time, to help us
get it consistently right rather than redoing the same math over and over.

3 files changed with 39 insertions and 17 deletions:

conservancy_beancount/reports/ledger.py

setup.py

tests/test_reports_ledger.py

0 comments (0 inline, 0 general)

conservancy_beancount/reports/ledger.py

➞

Show inline comments

@@ ... / @@ -48,63 +48,78 @@ import datetime @@
 import enum
 import itertools
 import operator
 import logging
 import sys
 from typing import (
     Callable,
     Dict,
     Iterable,
     Iterator,
     List,
     Mapping,
     Optional,
     Sequence,
     TextIO,
     Tuple,
     Union,
+)
 from pathlib import Path
 import odf.table  # type:ignore[import]
 from beancount.core import data as bc_data
 from beancount.parser import printer as bc_printer
 from . import core
 from .. import books
 from .. import cliutil
 from .. import config as configmod
 from .. import data
 from .. import ranges
 from .. import rtutil
 PostTally = List[Tuple[int, data.Account]]
 PROGNAME = 'ledger-report'
 logger = logging.getLogger('conservancy_beancount.reports.ledger')
 class AccountPostings(core.RelatedPostings):
     START_DATE: datetime.date
     def __init__(self,
                  source: Iterable[data.Posting]=(),
                  *,
                  _can_own: bool=False,
     ) -> None:
         super().__init__(source, _can_own=_can_own)
         self.start_bal = self.balance_at_cost_by_date(self.START_DATE)
         self.stop_bal = self.balance_at_cost()
         self.period_bal = self.stop_bal - self.start_bal
 class LedgerODS(core.BaseODS[data.Posting, data.Account]):
     CORE_COLUMNS: Sequence[str] = [
         'Date',
         data.Metadata.human_name('entity'),
         'Description',
         'Original Amount',
         'Booked Amount',
+    ]
     ACCOUNT_COLUMNS: Dict[str, Sequence[str]] = collections.OrderedDict([
         ('Income', ['project', 'rt-id', 'receipt', 'income-type']),
         ('Expenses', ['project', 'rt-id', 'receipt', 'approval', 'expense-allocation']),
         ('Equity', ['rt-id']),
         ('Assets:Receivable', ['project', 'rt-id', 'invoice', 'approval', 'contract', 'purchase-order']),
         ('Liabilities:Payable', ['project', 'rt-id', 'invoice', 'approval', 'contract', 'purchase-order']),
         ('Assets:PayPal', ['rt-id', 'paypal-id', 'receipt', 'approval']),
         ('Assets', ['rt-id', 'receipt', 'approval', 'bank-statement']),
         ('Liabilities', ['rt-id', 'receipt', 'approval', 'bank-statement']),
     ])
     # Excel 2003 was limited to 65,536 rows per worksheet.
     # While we can probably count on all our users supporting more modern
     # formats (Excel 2007 supports over 1 million rows per worksheet),
     # keeping the default limit conservative seems good to avoid running into
     # other limits (like the number of hyperlinks per worksheet), plus just
     # better for human organization and readability.
@@ ... @@
     def start_sheet(self, sheet_name: str) -> None:
         self.use_sheet(sheet_name.replace(':', ' '))
         columns_key = data.Account(sheet_name).is_under(*self.ACCOUNT_COLUMNS)
         # columns_key must not be None because ACCOUNT_COLUMNS has an entry
         # for all five root accounts.
         assert columns_key is not None
         self.metadata_columns = self.ACCOUNT_COLUMNS[columns_key]
         self.sheet_columns: Sequence[str] = [
             *self.CORE_COLUMNS,
             *(data.Metadata.human_name(meta_key) for meta_key in self.metadata_columns),
+        ]
         for col_name in self.sheet_columns:
             self.sheet.addElement(odf.table.TableColumn(
                 stylename=self.column_styles.get(col_name, self.default_column),
             ))
         self.add_row(*(
             self.string_cell(col_name, stylename=self.style_bold)
             for col_name in self.sheet_columns
         ))
         self.lock_first_row()
     def _report_section_balance(self, key: data.Account, date_key: str) -> None:
         uses_opening = key.is_under('Assets', 'Equity', 'Liabilities')
         related = self.account_groups[key]
         if date_key == 'start':
             if not uses_opening:
                 return
             date = self.date_range.start
             balance = related.start_bal
             description = "Opening Balance"
         else:
             date = self.date_range.stop
             description = "Ending Balance" if uses_opening else "Period Total"
         balance = self.norm_func(
             self.account_groups[key].balance_at_cost_by_date(date)
+        )
             if uses_opening:
                 balance = related.stop_bal
                 description = "Ending Balance"
             else:
                 balance = related.period_bal
                 description = "Period Total"
         self.add_row(
             self.date_cell(date, stylename=self.merge_styles(
                 self.style_bold, self.style_date,
             )),
             odf.table.TableCell(),
             self.string_cell(description, stylename=self.style_bold),
             odf.table.TableCell(),
             self.balance_cell(balance, stylename=self.style_bold),
+            self.balance_cell(self.norm_func(balance), stylename=self.style_bold),
+        )
     def start_section(self, key: data.Account) -> None:
         self.add_row()
         self.add_row(
             odf.table.TableCell(),
             self.string_cell(
                 f"{key} Ledger"
                 f" From {self.date_range.start.isoformat()}"
                 f" To {self.date_range.stop.isoformat()}",
                 stylename=self.style_bold,
                 numbercolumnsspanned=len(self.sheet_columns) - 1,
             ),
+        )
         self.norm_func = core.normalize_amount_func(key)
         self._report_section_balance(key, 'start')
     def end_section(self, key: data.Account) -> None:
         self._report_section_balance(key, 'stop')
     def write_row(self, row: data.Posting) -> None:
         if row.meta.date not in self.date_range:
             return
         elif row.cost is None:
             amount_cell = odf.table.TableCell()
         else:
             amount_cell = self.currency_cell(self.norm_func(row.units))
         self.add_row(
             self.date_cell(row.meta.date),
             self.string_cell(row.meta.get('entity') or ''),
             self.string_cell(row.meta.txn.narration),
             amount_cell,
             self.currency_cell(self.norm_func(row.at_cost())),
             *(self.meta_links_cell(row.meta.report_links(key))
               if key in data.LINK_METADATA
               else self.string_cell(row.meta.get(key, ''))
               for key in self.metadata_columns),
+        )
     def _combined_balance_row(self,
                               date: datetime.date,
                               balance_accounts: Sequence[str],
                               attr_name: str,
     ) -> None:
         date = getattr(self.date_range, attr_name)
         balance_attrname = f'{attr_name}_bal'
         balance = -sum((
-            related.balance_at_cost_by_date(date)
+            getattr(related, balance_attrname)
             for account, related in self.account_groups.items()
             if account.is_under(*balance_accounts)
         ), core.MutableBalance())
         self.add_row(
             self.string_cell(
                 f"Balance as of {date.isoformat()}",
                 stylename=self.merge_styles(self.style_bold, self.style_endtext),
             ),
             self.balance_cell(balance, stylename=self.style_bold),
+        )
     def write_balance_sheet(self) -> None:
         balance_accounts = ['Equity', 'Income', 'Expenses']
         # FIXME: This is a hack to exclude non-project Equity accounts from
         # project reports.
         if balance_accounts[0] not in self.required_sheet_names:
             balance_accounts[0] = 'Equity:Funds'
         self.use_sheet("Balance")
         self.sheet.addElement(odf.table.TableColumn(stylename=self.column_style(3)))
         self.sheet.addElement(odf.table.TableColumn(stylename=self.column_style(1.5)))
         self.add_row(
             self.string_cell("Account", stylename=self.style_bold),
             self.string_cell("Balance", stylename=self.style_bold),
+        )
         self.lock_first_row()
         self.add_row()
         self.add_row(self.string_cell(
             f"Ledger From {self.date_range.start.isoformat()}"
             f" To {self.date_range.stop.isoformat()}",
             stylename=self.merge_styles(self.style_centertext, self.style_bold),
             numbercolumnsspanned=2,
         ))
         self.add_row()
-        self._combined_balance_row(self.date_range.start, balance_accounts)
+        self._combined_balance_row(balance_accounts, 'start')
         for _, account in self._sort_and_filter_accounts(
                 self.account_groups, balance_accounts,
         ):
             related = self.account_groups[account]
             # start_bal - stop_bal == -(stop_bal - start_bal)
             balance = related.balance_at_cost_by_date(self.date_range.start)
             balance -= related.balance_at_cost_by_date(self.date_range.stop)
             balance = self.account_groups[account].period_bal
             if not balance.is_zero():
                 self.add_row(
                     self.string_cell(account, stylename=self.style_endtext),
                     self.balance_cell(balance),
+                    self.balance_cell(-balance),
+                )
-        self._combined_balance_row(self.date_range.stop, balance_accounts)
+        self._combined_balance_row(balance_accounts, 'stop')
     def write(self, rows: Iterable[data.Posting]) -> None:
         self.account_groups = dict(core.RelatedPostings.group_by_account(rows))
         AccountPostings.START_DATE = self.date_range.start
         self.account_groups = dict(AccountPostings.group_by_account(
             post for post in rows if post.meta.date < self.date_range.stop
         ))
         self.write_balance_sheet()
         tally_by_account_iter = (
             (account, sum(1 for post in related if post.meta.date in self.date_range))
             for account, related in self.account_groups.items()
+        )
         tally_by_account = {
             account: count
             for account, count in tally_by_account_iter
             if count
+        }
         sheet_names = self.plan_sheets(
             tally_by_account, self.required_sheet_names, self.sheet_size,
+        )
         using_sheet_index = -1
         for sheet_index, account in self._sort_and_filter_accounts(
                 tally_by_account, sheet_names,
         ):
             while using_sheet_index < sheet_index:
                 using_sheet_index += 1
                 self.start_sheet(sheet_names[using_sheet_index])
             super().write(self.account_groups[account])
         for index in range(using_sheet_index + 1, len(sheet_names)):
             self.start_sheet(sheet_names[index])

setup.py

➞

Show inline comments

 #!/usr/bin/env python3
 from setuptools import setup
 setup(
     name='conservancy_beancount',
     description="Plugin, library, and reports for reading Conservancy's books",
-    version='1.2.5',
+    version='1.2.6',
     author='Software Freedom Conservancy',
     author_email='info@sfconservancy.org',
     license='GNU AGPLv3+',
     install_requires=[
         'babel>=2.6',  # Debian:python3-babel
         'beancount>=2.2',  # Debian:beancount
         # 1.4.1 crashes when trying to save some documents.
         'odfpy>=1.4.0,!=1.4.1',  # Debian:python3-odf
         'PyYAML>=3.0',  # Debian:python3-yaml
         'regex',  # Debian:python3-regex
         'rt>=2.0',
     ],
     setup_requires=[
         'pytest-mypy',
         'pytest-runner',  # Debian:python3-pytest-runner
     ],
     tests_require=[
         'mypy>=0.770',  # Debian:python3-mypy
         'pytest',  # Debian:python3-pytest
     ],
     packages=[
         'conservancy_beancount',

tests/test_reports_ledger.py

➞

Show inline comments

@@ ... / @@ -88,65 +88,66 @@ class ExpectedPostings(core.RelatedPostings): @@
         return (self[:start_index].balance_at_cost(),
                 self[start_index:end_index])
     def check_report(self, ods, start_date, end_date):
         account = self[0].account
         norm_func = core.normalize_amount_func(account)
         open_bal, expect_posts = self.slice_date_range(start_date, end_date)
         open_bal = norm_func(open_bal)
         for sheet in ods.getElementsByType(odf.table.Table):
             sheet_account = sheet.getAttribute('name').replace(' ', ':')
             if sheet_account and account.is_under(sheet_account):
                 break
         else:
             raise NoSheet(account)
         rows = iter(sheet.getElementsByType(odf.table.TableRow))
         for row in rows:
             cells = row.childNodes
             if len(cells) == 2 and cells[-1].text.startswith(f'{account} '):
                 break
         else:
             if expect_posts:
                 raise NoHeader(account)
             else:
                 return
         closing_bal = norm_func(expect_posts.balance_at_cost())
         if account.is_under('Assets', 'Equity', 'Liabilities'):
             opening_row = testutil.ODSCell.from_row(next(rows))
             assert opening_row[0].value == start_date
             assert opening_row[4].text == open_bal.format(None, empty='0', sep='\0')
             closing_bal += open_bal
         for expected in expect_posts:
             cells = iter(testutil.ODSCell.from_row(next(rows)))
             assert next(cells).value == expected.meta.date
             assert next(cells).text == (expected.meta.get('entity') or '')
             assert next(cells).text == (expected.meta.txn.narration or '')
             if expected.cost is None:
                 assert not next(cells).text
                 assert next(cells).value == norm_func(expected.units.number)
             else:
                 assert next(cells).value == norm_func(expected.units.number)
                 assert next(cells).value == norm_func(expected.at_cost().number)
         closing_row = testutil.ODSCell.from_row(next(rows))
         closing_bal = open_bal + norm_func(expect_posts.balance_at_cost())
         assert closing_row[0].value == end_date
         assert closing_row[4].text == closing_bal.format(None, empty='0', sep='\0')
 def get_sheet_names(ods):
     return [sheet.getAttribute('name').replace(' ', ':')
             for sheet in ods.getElementsByType(odf.table.Table)]
 def check_oversize_logs(caplog, accounts, sheet_size):
     actual = {}
     for log in caplog.records:
         match = OVERSIZE_RE.match(log.message)
         if match:
             assert int(match.group(3).replace(',', '')) == sheet_size
             actual[match.group(1)] = int(match.group(2).replace(',', ''))
     expected = {name: size for name, size in accounts.items() if size > sheet_size}
     assert actual == expected
 def test_plan_sheets_no_change():
     have = {
         Acct('Assets:Cash'): 10,
         Acct('Income:Donations'): 20,
+    }
     want = ['Assets', 'Income']

0 comments (0 inline, 0 general)