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

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

        raise NotImplementedError("BaseReport._report")

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

        for index, invoice in enumerate(groups):

            for line in self._report(groups[invoice], index):

                print(line, file=self.out_file)

class AgingODS(core.BaseODS[AccrualPostings, Optional[data.Account]]):

    DOC_COLUMNS = [

        'rt-id',

        'invoice',

        'approval',

        'contract',

        'purchase-order',

    ]

    COLUMNS = [

        'Date',

        data.Metadata.human_name('entity'),

        'Invoice Amount',

        'Booked Amount',

        data.Metadata.human_name('project'),

        *(data.Metadata.human_name(key) for key in DOC_COLUMNS),

    ]

    COL_COUNT = len(COLUMNS)

    def __init__(self,

                 rt_wrapper: rtutil.RT,

                 date: datetime.date,

                 logger: logging.Logger,

    ) -> None:

        super().__init__(rt_wrapper)

        self.date = date

        self.logger = logger

    def section_key(self, row: AccrualPostings) -> Optional[data.Account]:

        if isinstance(row.account, str):

            return row.account

        else:

            return None

    def start_spreadsheet(self) -> None:

        for accrual_type in AccrualAccount:

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

            for index in range(self.COL_COUNT):

            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: Optional[data.Account]) -> None:

        if key is None:

            return

        self.age_thresholds = list(AccrualAccount.by_account(key).value.aging_thresholds)

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

        accrual_date = self.date - datetime.timedelta(days=self.age_thresholds[-1])

        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" Accrued by {accrual_date.isoformat()} Unpaid by {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: Optional[data.Account]) -> None:

        if key is None:

            return

        total_balance = core.MutableBalance()

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

        text_span = 4

        last_age_text: Optional[str] = None

        self.add_row()

        for threshold, balance in zip(self.age_thresholds, self.age_balances):

            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}"

            else:

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

            self.add_row(

                self.string_cell(

                    f"Total Aged {age_range}: ",

        ...

    # The next four methods are all called by the write method when the name

    # says. You may override them to output headers or sums, record

    # state, etc. The default implementations are all noops.

    def start_spreadsheet(self) -> None:

        pass

    def start_section(self, key: ST) -> None:

        pass

    def end_section(self, key: ST) -> None:

        pass

    def end_spreadsheet(self) -> None:

        pass

    def write(self, rows: Iterable[RT]) -> None:

        prev_section: Optional[ST] = None

        self.start_spreadsheet()

        for row in rows:

            section = self.section_key(row)

            if section != prev_section:

                if prev_section is not None:

                    self.end_section(prev_section)

                self.start_section(section)

                prev_section = section

            self.write_row(row)

        try:

            should_end = section is not None

        except NameError:

            should_end = False

        if should_end:

            self.end_section(section)

        self.end_spreadsheet()

class BaseODS(BaseSpreadsheet[RT, ST], metaclass=abc.ABCMeta):

    """Abstract base class to help write OpenDocument spreadsheets

    This class provides the very core logic to write an arbitrary set of data

    rows to an OpenDocument spreadsheet. It provides helper methods for

    building sheets, rows, and cells.

    See also the BaseSpreadsheet base class for additional documentation about

    methods you must and can define, the definition of RT and ST, etc.

    """

    def __init__(self, rt_wrapper: Optional[rtutil.RT]=None) -> None:

        self.rt_wrapper = rt_wrapper

        self.locale = babel.core.Locale.default('LC_MONETARY')

        self.currency_fmt_key = 'accounting'

        self._name_counter = itertools.count(1)

        self._currency_style_cache: MutableMapping[str, odf.style.Style] = {}

        self.document = odf.opendocument.OpenDocumentSpreadsheet()

        self.init_settings()

        self.init_styles()

        self.sheet = self.use_sheet("Report")

    ### Low-level document tree manipulation

    # The *intent* is that you only need to use these if you're adding new

    # methods to manipulate document settings or styles.

    def copy_element(self, elem: odf.element.Element) -> odf.element.Element:

        qattrs = dict(self.iter_qattributes(elem))

        retval = odf.element.Element(qname=elem.qname, qattributes=qattrs)

        try:

            orig_name = retval.getAttribute('name')

        except ValueError:

            orig_name = None

        if orig_name is not None:

            retval.setAttribute('name', f'{orig_name}{next(self._name_counter)}')

        return retval

    def ensure_child(self,

                     parent: odf.element.Element,

                     child_type: ElementType,

                     **kwargs: Any,

    ) -> odf.element.Element:

        new_child = child_type(**kwargs)

        found_child = self.find_child(parent, new_child)

        if found_child is None:

            parent.addElement(new_child)

            return parent.lastChild

        else:

            return found_child

    def ensure_config_map_entry(self,

                                root: odf.element.Element,

                                map_name: str,

                                entry_name: str,

    ) -> odf.element.Element:

        """Return a ``ConfigItemMapEntry`` under ``root``

        This method ensures there's a ``ConfigItemMapNamed`` named ``map_name``

        under ``root``, and a ``ConfigItemMapEntry`` named ``entry_name`` under

    def iter_attributes(self, elem: odf.element.Element) -> Iterator[Tuple[str, str]]:

        for (_, key), value in self.iter_qattributes(elem):

            yield key.lower().replace('-', ''), value

    def iter_qattributes(self, elem: odf.element.Element) -> Iterator[Tuple[Tuple[str, str], str]]:

        if elem.attributes:

            yield from elem.attributes.items()

    def replace_child(self,

                     parent: odf.element.Element,

                     child_type: ElementType,

                     **kwargs: Any,

    ) -> odf.element.Element:

        new_child = child_type(**kwargs)

        found_child = self.find_child(parent, new_child)

        parent.insertBefore(new_child, found_child)

        if found_child is not None:

            parent.removeChild(found_child)

        return new_child

    def set_config(self,

                   root: odf.element.Element,

                   name: str,

                   value: Union[bool, int, str],

                   config_type: Optional[str]=None,

    ) -> None:

        """Ensure ``root`` has a ``ConfigItem`` with the given name, type, and value"""

        value_s = str(value)

        if isinstance(value, bool):

            value_s = str(value).lower()

            default_type = 'boolean'

        elif isinstance(value, str):

            default_type = 'string'

        if config_type is None:

            try:

                config_type = default_type

            except NameError:

                raise ValueError(

                    f"need config_type for {type(value).__name__} value",

                ) from None

        item = self.replace_child(

            root, odf.config.ConfigItem, name=name, type=config_type,

        )

        item.addText(value_s)

    ### Styles

    def _build_currency_style(

            self,

            root: odf.element.Element,

            locale: babel.core.Locale,

            code: str,

            fmt_index: int,

            properties: Optional[odf.style.TextProperties]=None,

            *,

            fmt_key: Optional[str]=None,

            volatile: bool=False,

            minintegerdigits: int=1,

    ) -> odf.element.Element:

        if fmt_key is None:

            fmt_key = self.currency_fmt_key

        pattern = locale.currency_formats[fmt_key]

        fmts = pattern.pattern.split(';')

        try:

            fmt = fmts[fmt_index]

        except IndexError:

            fmt = fmts[0]

            grouping = pattern.grouping[0]

        else:

            grouping = pattern.grouping[fmt_index]

        zero_s = babel.numbers.format_currency(0, code, '##0.0', locale)

        try:

            decimal_index = zero_s.rindex('.') + 1

        except ValueError:

            decimalplaces = 0

        else:

            decimalplaces = len(zero_s) - decimal_index

        style = self.replace_child(

            root,

            odf.number.CurrencyStyle,

            name=f'{code}{next(self._name_counter)}',

        )

        style.setAttribute('volatile', 'true' if volatile else 'false')

        if properties is not None:

            style.addElement(properties)

        for part in re.split(r"(¤+|[#0,.]+|'[^']+')", fmt):

            if not part:

                pass

            elif not part.strip('#0,.'):

                style.addElement(odf.number.Number(

                    decimalplaces=str(decimalplaces),

                    grouping='true' if grouping else 'false',

                    minintegerdigits=str(minintegerdigits),

                ))

            elif part == '¤':

    def init_styles(self) -> None:

        """Hook called to initialize settings

        This method is called by __init__ to populate

        ``self.document.styles``. This implementation creates basic building

        block cell styles often used in financial reports.

        """

        styles = self.document.styles

        self.style_bold = self.ensure_child(

            styles, odf.style.Style, name='Bold', family='table-cell',

        )

        self.ensure_child(

            self.style_bold, odf.style.TextProperties, fontweight='bold',

        )

        self.style_dividerline = self.ensure_child(

            styles, odf.style.Style, name='DividerLine', family='table-cell',

        )

        self.ensure_child(

            self.style_dividerline,

            odf.style.TableCellProperties,

            borderbottom='1pt solid #0000ff',

        )

        date_style = self.replace_child(styles, odf.number.DateStyle, name='ISODate')

        date_style.addElement(odf.number.Year(style='long'))

        date_style.addElement(odf.number.Text(text='-'))

        date_style.addElement(odf.number.Month(style='long'))

        date_style.addElement(odf.number.Text(text='-'))

        date_style.addElement(odf.number.Day(style='long'))

        self.style_date = self.ensure_child(

            styles,

            odf.style.Style,

            name=f'{date_style.getAttribute("name")}Cell',

            family='table-cell',

            datastylename=date_style,

        )

        self.style_starttext: odf.style.Style

        self.style_centertext: odf.style.Style

        self.style_endtext: odf.style.Style

        for textalign in ['start', 'center', 'end']:

            aligned_style = self.replace_child(

                styles, odf.style.Style, name=f'{textalign.title()}Text',

            )

            aligned_style.setAttribute('family', 'table-cell')

            aligned_style.addElement(odf.style.ParagraphProperties(textalign=textalign))

            setattr(self, f'style_{textalign}text', aligned_style)

    ### Rows and cells

    def add_row(self, *cells: odf.table.TableCell, **attrs: Any) -> odf.table.TableRow:

        row = odf.table.TableRow(**attrs)

        for cell in cells:

            row.addElement(cell)

        self.sheet.addElement(row)

        return row

    def balance_cell(self, balance: Balance, **attrs: Any) -> odf.table.TableCell:

        if balance.is_zero():

            return self.float_cell(0, **attrs)

        elif len(balance) == 1:

            amount = next(iter(balance.values()))

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.currency_style(amount.currency),

            )

            return self.currency_cell(amount, **attrs)

        else:

            lines = [babel.numbers.format_currency(

                number, currency, locale=self.locale, format_type=self.currency_fmt_key,

            ) for number, currency in balance.values()]

            attrs['stylename'] = self.merge_styles(

                attrs.get('stylename'), self.style_endtext,

            )

            return self.multiline_cell(lines, **attrs)

    def currency_cell(self, amount: data.Amount, **attrs: Any) -> odf.table.TableCell:

        if 'stylename' not in attrs:

            attrs['stylename'] = self.currency_style(amount.currency)

        number, currency = amount

        cell = odf.table.TableCell(valuetype='currency', value=number, **attrs)

        cell.addElement(odf.text.P(text=babel.numbers.format_currency(

            number, currency, locale=self.locale, format_type=self.currency_fmt_key,

        )))

        return cell

    def date_cell(self, date: datetime.date, **attrs: Any) -> odf.table.TableCell:

        attrs.setdefault('stylename', self.style_date)

        cell = odf.table.TableCell(valuetype='date', datevalue=date, **attrs)

        cell.addElement(odf.text.P(text=date.isoformat()))

        return cell

    def float_cell(self, value: Union[int, float, Decimal], **attrs: Any) -> odf.table.TableCell:

        cell = odf.table.TableCell(valuetype='float', value=value, **attrs)

        cell.addElement(odf.text.P(text=str(value)))

        return cell

Run ``ledger-report --help`` for abbreviations and other options.

Examples

--------

Report all activity related to a given project::

    ledger-report project=NAME

Get all Assets postings for a given month to help with reconciliation::

    ledger-report -a Assets -b 2018-05-01 -e 2018-06-01

"""

# Copyright © 2020  Brett Smith

#

# This program is free software: you can redistribute it and/or modify

# it under the terms of the GNU Affero General Public License as published by

# the Free Software Foundation, either version 3 of the License, or

# (at your option) any later version.

#

# This program is distributed in the hope that it will be useful,

# but WITHOUT ANY WARRANTY; without even the implied warranty of

# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the

# GNU Affero General Public License for more details.

#

# You should have received a copy of the GNU Affero General Public License

# along with this program.  If not, see <https://www.gnu.org/licenses/>.

import argparse

import collections

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,

)

from pathlib import Path

import odf.table  # type:ignore[import]

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 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.

    SHEET_SIZE = 65000

    def __init__(self,

                 start_date: datetime.date,

                 stop_date: datetime.date,

                 sheet_names: Optional[Sequence[str]]=None,

                 rt_wrapper: Optional[rtutil.RT]=None,

                 sheet_size: Optional[int]=None,

    ) -> None:

        if sheet_names is None:

            sheet_names = list(self.ACCOUNT_COLUMNS)

        if sheet_size is None:

            sheet_size = self.SHEET_SIZE

        super().__init__(rt_wrapper)

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

        self.required_sheet_names = sheet_names

        self.sheet_size = sheet_size

    @classmethod

    def _group_tally(

            cls,

            tally_by_account: PostTally,

            key: Callable[[data.Account], Optional[str]],

    ) -> Dict[str, PostTally]:

        retval: Dict[str, PostTally] = collections.defaultdict(list)

        for count, account in tally_by_account:

            item_key = key(account)

            if item_key is not None:

                retval[item_key].append((count, account))

        return retval

    @classmethod

    def _split_sheet(

            cls,

            tally_by_account: PostTally,

            sheet_size: int,

            sheet_name: str,

    ) -> Iterator[str]:

        total = 0

        for index, (count, account) in enumerate(tally_by_account):

            total += count

            if total > sheet_size:

                break

        else:

            # All the accounts fit in this sheet.

            yield sheet_name

            return

        if index == 0 and len(tally_by_account) == 1:

            # With one account, we can't split any further, so warn and stop.

            logger.warning(

                "%s has %s rows, over size %s",

                account, f'{count:,g}', f'{sheet_size:,g}',

            )

            yield sheet_name

            return

        group_func = operator.methodcaller('root_part', sheet_name.count(':') + 2)

        maybe_split = cls._group_tally(tally_by_account[:index], group_func)

        must_split = cls._group_tally(tally_by_account[index:], group_func)

        for subkey, must_split_tally in sorted(must_split.items()):

            split_names = cls._split_sheet(

                maybe_split.get(subkey, []) + must_split_tally, sheet_size, subkey,

            )

            # We must be willing to split out at least as many sheets as there

            # are accounts that didn't fit. Do that first.

            yield from itertools.islice(split_names, len(must_split_tally))

            # After that, we can be in one of two cases:

        sorted_tally: PostTally = [

            (count, account)

            for account, count in tally_by_account.items()

        ]

        sorted_tally.sort()

        split_tally = cls._group_tally(

            sorted_tally,

            operator.methodcaller('is_under', *base_sheets),

        )

        return [

            sheet_name

            for key in base_sheets

            for sheet_name in cls._split_sheet(split_tally[key], sheet_size, key)

        ]

    @staticmethod

    def _sort_and_filter_accounts(

            accounts: Iterable[data.Account],

            order: Sequence[str],

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

        index_map = {s: ii for ii, s in enumerate(order)}

        retval: Mapping[int, List[data.Account]] = collections.defaultdict(list)

        for account in accounts:

            acct_key = account.is_under(*order)

            if acct_key is not None:

                retval[index_map[acct_key]].append(account)

        for key in sorted(retval):

            acct_list = retval[key]

            acct_list.sort()

            for account in acct_list:

                yield key, account

    def section_key(self, row: data.Posting) -> data.Account:

        return row.account

    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(

            ))

        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')

        if date_key == 'start':

            if not uses_opening:

                return

            date = self.date_range.start

            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)

        )

        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),

        )

    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],

    ) -> None:

        balance = -sum((

            related.balance_at_cost_by_date(date)

            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.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)

        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)

            if not balance.is_zero():

                self.add_row(

                    self.string_cell(account, stylename=self.style_endtext),

                    self.balance_cell(balance),

                )

        self._combined_balance_row(self.date_range.stop, balance_accounts)

    def write(self, rows: Iterable[data.Posting]) -> None:

        self.account_groups = dict(core.RelatedPostings.group_by_account(rows))

        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:

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

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