cliutil.diff_year(start_date, -1),

            cliutil.diff_year(stop_date, -1),

        )

        assert self.prior_range.stop <= start_date

        self.period_range = ranges.DateRange(start_date, stop_date)

        self.balances: Mapping[BalanceKey, core.MutableBalance] \

            = collections.defaultdict(core.MutableBalance)

        for post in postings:

            post_date = post.meta.date

            if post_date in self.period_range:

                period = Period.PERIOD

            elif post_date in self.prior_range:

                period = Period.PRIOR

            elif post_date < self.prior_range.start:

                period = Period.OPENING

            else:

                continue

            if post.account == 'Expenses:CurrencyConversion':

                account = data.Account('Income:CurrencyConversion')

            else:

                account = post.account

            if post.meta.get(fund_key) == unrestricted_fund_value:

                fund = Fund.UNRESTRICTED

            else:

                fund = Fund.RESTRICTED

            try:

                classification_s = account.meta['classification']

                if isinstance(classification_s, str):

                    classification = data.Account(classification_s)

                else:

                    raise TypeError()

            except (KeyError, TypeError):

                classification = account

            if account.root_part() == 'Expenses':

                post_type = post.meta.get('expense-type')

            else:

                post_type = None

            key = BalanceKey(account, classification, period, fund, post_type)

            self.balances[key] += post.at_cost()

    def total(self,

              account: Union[None, str, Collection[str]]=None,

              classification: Optional[str]=None,

              period: int=Period.ANY,

              fund: int=Fund.ANY,

              post_type: Optional[str]=None,

    ) -> core.Balance:

        if isinstance(account, str):

            account = (account,)

        retval = core.MutableBalance()

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

            if not (account is None or key.account.is_under(*account)):

                pass

            elif not (classification is None

                      or key.classification.is_under(classification)):

                pass

            elif not period & key.period:

                pass

            elif not fund & key.fund:

                pass

            elif not (post_type is None or post_type == key.post_type):

                pass

            else:

                retval += balance

        return retval

    def classifications(self,

                        account: str,

                        sort_period: Optional[int]=None,

    ) -> Sequence[data.Account]:

        if sort_period is None:

            if account in EQUITY_ACCOUNTS:

                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

            elif key.period & sort_period:

                class_bals[key.classification] += balance

            else:

                # Ensure the balance exists in the mapping

                class_bals[key.classification]

        norm_func = core.normalize_amount_func(f'{account}:RootsOK')

        def sortkey(acct: data.Account) -> Hashable:

            prefix, _, _ = acct.rpartition(':')

            balance = norm_func(class_bals[acct])

            try:

                max_bal = max(amount.number for amount in balance.values())

            except ValueError:

                max_bal = Decimal(0)

            return prefix, -max_bal

        return sorted(class_bals, key=sortkey)

        start_date = self.period_range.start

        stop_date = self.period_range.stop

class Report(core.BaseODS[Sequence[None], None]):

    C_CASH = 'Cash'

    C_SATISFIED = 'Satisfaction of program restrictions'

    NO_BALANCE = core.Balance()

    SPACE = ' ' * 4

    def __init__(self,

                 balances: Balances,

                 *,

                 date_fmt: str='%B %d, %Y',

    ) -> None:

        super().__init__()

        self.balances = balances

        self.date_fmt = date_fmt

        one_day = datetime.timedelta(days=1)

        date = balances.period_range.stop - one_day

        self.period_name = date.strftime(date_fmt)

        date = balances.prior_range.stop - one_day

        self.opening_name = date.strftime(date_fmt)

        self.last_totals_row = odf.table.TableRow()

    def section_key(self, row: Sequence[None]) -> None:

        raise NotImplementedError("balance_sheet.Report.section_key")

    def init_styles(self) -> None:

        super().init_styles()

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

        self.style_huline = self.merge_styles(

            self.style_header,

            self.border_style(core.Border.BOTTOM, '1pt'),

        )

        self.style_subtotline = self.border_style(core.Border.TOP, '1pt')

        self.style_totline = self.border_style(core.Border.TOP | core.Border.BOTTOM, '1pt')

        self.style_bottomline = self.merge_styles(

            self.style_subtotline,

            self.border_style(core.Border.BOTTOM, '2pt', 'double'),

        )

    def write_all(self) -> None:

        self.write_financial_position()

        self.write_activities()

        self.write_functional_expenses()

        self.write_cash_flows()

        self.write_trial_balances()

    def walk_classifications(self, cseq: Iterable[data.Account]) \

        -> Iterator[Tuple[str, Optional[data.Account]]]:

        last_prefix: Sequence[str] = []

        for classification in cseq:

            parts = classification.split(':')

            tail = parts.pop()

            space = self.SPACE * len(parts)

            if parts != last_prefix:

                yield f'{space[len(self.SPACE):]}{parts[-1]}', None

                last_prefix = parts

            yield f'{space}{tail}', classification

    def walk_classifications_by_account(

            self,

            account: str,

            sort_period: Optional[int]=None,

    ) -> Iterator[Tuple[str, Optional[data.Account]]]:

        return self.walk_classifications(self.balances.classifications(

            account, sort_period,

        ))

    def start_sheet(self,

                    sheet_name: str,

                    *headers: Iterable[str],

                    totals_prefix: Sequence[str]=(),

                    first_width: Union[float, str]=3,

                    width: Union[float, str]=1.5,

                    title_fmt: str="DRAFT Statement of {sheet_name}",

    ) -> None:

        header_cells: Sequence[odf.table.TableCell] = [

            odf.table.TableCell(),

            *(self.multiline_cell(header_lines, stylename=self.style_huline)

              for header_lines in headers),

            *(self.multiline_cell([*totals_prefix, date_s], stylename=self.style_huline)

              for date_s in [self.period_name, self.opening_name]),

        ]

        self.col_count = len(header_cells)

        self.use_sheet(sheet_name)

        for index in range(self.col_count):

            col_style = self.column_style(width if index else first_width)

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

        start_date = self.balances.period_range.start.strftime(self.date_fmt)

        self.add_row(

            self.multiline_cell([

                title_fmt.format(sheet_name=sheet_name),

                f"{start_date}—{self.period_name}",

            ], numbercolumnsspanned=self.col_count, stylename=self.style_header)

        )

        self.add_row()

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

        ],

    },

)