self.use_sheet(accrual_type.name.title())

            for index in range(self.COL_COUNT):

                if index == 0:

                    style: Union[str, odf.style.Style] = ''

                elif index < 6:

                    style = self.column_style(1.2)

                else:

                    style = self.column_style(1.5)

                self.sheet.addElement(odf.table.TableColumn(stylename=style))

            self.add_row(*(

                self.string_cell(name, stylename=self.style_bold)

                for name in self.COLUMNS

            ))

            self.lock_first_row()

    def start_section(self, key: data.Account) -> None:

        accrual_type = AccrualAccount.by_account(key)

        self.norm_func = accrual_type.normalize_amount

        self.age_thresholds = list(accrual_type.value.aging_thresholds)

        self.age_thresholds.append(-sys.maxsize)

        self.age_balances = [core.MutableBalance() for _ in self.age_thresholds]

        self.age_styles = [

            self.merge_styles(self.style_date, self.border_style(

                core.Border.LEFT, '10pt', 'solid', color,

            )) for color in self.AGE_COLORS

        ]

        acct_parts = key.slice_parts()

        self.use_sheet(acct_parts[1])

        self.add_row()

        self.add_row(self.string_cell(

            f"{' '.join(acct_parts[2:])} {acct_parts[1]} Aging Report"

            f" for {self.date.isoformat()}",

            stylename=self.merge_styles(self.style_bold, self.style_centertext),

            numbercolumnsspanned=self.COL_COUNT,

        ))

        self.add_row()

    def end_section(self, key: data.Account) -> None:

        total_balance = core.MutableBalance()

        text_span = 4

        last_age_text: Optional[str] = None

        self.add_row()

        for threshold, balance, style in zip(

                self.age_thresholds, self.age_balances, self.age_styles,

        ):

            years, days = divmod(threshold, 365)

            years_text = f"{years} {'Year' if years == 1 else 'Years'}"

            days_text = f"{days} Days"

            if years and days:

                age_text = f"{years_text} {days_text}"

            elif years:

                age_text = years_text

            else:

                age_text = days_text

            if last_age_text is None:

                age_range = f"Over {age_text}"

            elif threshold < 0:

                self.add_row(

                    self.string_cell(

                        f"Total Unpaid Over {last_age_text}: ",

                        stylename=self.merge_styles(self.style_bold, self.style_endtext),

                        numbercolumnsspanned=text_span,

                    ),

                    *(odf.table.TableCell() for _ in range(1, text_span)),

                )

                age_range = f"Under {last_age_text}"

            else:

                age_range = f"{age_text}–{last_age_text}"

            self.add_row(

                self.string_cell(

                    f"Total Aged {age_range}: ",

                    stylename=self.merge_styles(self.style_bold, self.style_endtext, style),

                    numbercolumnsspanned=text_span,

                ),

                *(odf.table.TableCell() for _ in range(1, text_span)),

                self.balance_cell(balance),

            )

            last_age_text = age_text

            total_balance += balance

        self.add_row(

            self.string_cell(

                "Total Unpaid: ",

                stylename=self.merge_styles(self.style_bold, self.style_endtext),

                numbercolumnsspanned=text_span,

            ),

            *(odf.table.TableCell() for _ in range(1, text_span)),

        )

    def write_row(self, row: AccrualPostings) -> None:

        row_date = row[0].meta.date

        row_balance = self.norm_func(row.balance_at_cost())

        age = (self.date - row_date).days

        for index, threshold in enumerate(self.age_thresholds):

            if age >= threshold:

                if row_balance.ge_zero():

                    self.age_balances[index] += row_balance

                break

        else:

            return

        raw_balance = self.norm_func(row.balance())

        if raw_balance == row_balance:

            amount_cell = odf.table.TableCell()

        else:

            amount_cell = self.balance_cell(raw_balance)

        entities = row.meta_values('entity')

        entities.discard(None)

        projects = row.meta_values('project')

        projects.discard(None)

        self.add_row(

            self.date_cell(row_date, stylename=self.age_styles[index]),

            self.multiline_cell(sorted(entities)),

            amount_cell,

            self.balance_cell(row_balance),

            self.multiline_cell(sorted(projects)),

            *(self.meta_links_cell(row.all_meta_links(key))

              for key in self.DOC_COLUMNS),

        )

class AgingReport(BaseReport):

    def __init__(self,

                 rt_wrapper: rtutil.RT,

                 out_file: BinaryIO,

                 date: Optional[datetime.date]=None,

    ) -> None:

        if date is None:

            date = datetime.date.today()

        self.out_bin = out_file

        self.logger = logger.getChild(type(self).__name__)

        self.ods = AgingODS(rt_wrapper, date, self.logger)

    def run(self, groups: PostGroups) -> None:

        rows = [group for group in groups.values()

                if not group.balance_at_cost().is_zero()]

        rows.sort(key=lambda group: (

            group[0].account,

            group[0].meta.date,

            abs(sum(amt.number for amt in group.balance_at_cost().values())),

        ))

        self.ods.write(rows)

        self.ods.save_file(self.out_bin)

class BalanceReport(BaseReport):

    def _report(self, posts: AccrualPostings, index: int) -> Iterable[str]:

        meta = posts[0].meta

        date_s = meta.date.strftime('%Y-%m-%d')

        entity_s = meta.get('entity', '<no entity>')

        invoice_s = meta.get('invoice', '<no invoice>')

        balance_s = posts.balance_at_cost().format(zero="Zero balance")

#!/usr/bin/env python3

from setuptools import setup

setup(

    name='conservancy_beancount',

    description="Plugin, library, and reports for reading Conservancy's books",

    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

        'GitPython>=2.0',  # Debian:python3-git

        # 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',

        'conservancy_beancount.plugin',

        'conservancy_beancount.reports',

    ],

    entry_points={

        'console_scripts': [

            'accrual-report = conservancy_beancount.reports.accrual:entry_point',

            'balance-sheet-report = conservancy_beancount.reports.balance_sheet:entry_point',

            'extract-odf-links = conservancy_beancount.tools.extract_odf_links:entry_point',

            'fund-report = conservancy_beancount.reports.fund:entry_point',

            'ledger-report = conservancy_beancount.reports.ledger:entry_point',

            'opening-balances = conservancy_beancount.tools.opening_balances:entry_point',

        ],

    },

)