self.document.styles.addElement(retval)

            self._style_cache[key] = retval

        return retval

    def column_style(self, width: Union[float, str], **attrs: Any) -> odf.style.Style:

        if not isinstance(width, str) or (width and not width[-1].isalpha()):

            width = f'{width}in'

        match = self.MEASUREMENT_RE.fullmatch(width)

        if match is None:

            raise ValueError(f"invalid width {width!r}")

        width_float = float(match.group(1))

        if width_float <= 0:

            # Per the OpenDocument spec, column-width is a positiveLength.

            raise ValueError(f"width {width!r} must be positive")

        width = '{:.3g}{}'.format(width_float, match.group(2))

        retval = self.ensure_child(

            self.document.automaticstyles,

            odf.style.Style,

            name=f'col_{width.replace(".", "_")}'

        )

        retval.setAttribute('family', 'table-column')

        if retval.firstChild is None:

            retval.addElement(odf.style.TableColumnProperties(

                columnwidth=width, **attrs

            ))

        return retval

    def _build_currency_style(

            self,

            root: odf.element.Element,

            locale: babel.core.Locale,

            code: str,

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

            *,

            fmt_key: Optional[str]=None,

            volatile: bool=False,

    ) -> odf.element.Element:

        if fmt_key is None:

            fmt_key = self.currency_fmt_key

        pattern = locale.currency_formats[fmt_key]

        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(pattern.frac_prec[0]),

                    grouping='true' if pattern.grouping[0] else 'false',

                    minintegerdigits=str(pattern.int_prec[0]),

                ))

            elif part == '¤':

                style.addElement(odf.number.CurrencySymbol(

                    country=locale.territory,

                    language=locale.language,

                    text=babel.numbers.get_currency_symbol(code, locale),

                ))

            elif part == '¤¤':

                style.addElement(odf.number.Text(text=code))

            else:

                style.addElement(odf.number.Text(text=part.strip("'")))

        return style

    def currency_style(

            self,

            code: str,

        styles necessary to format the currency according to the locale's

        rules, including rendering of decimal points and negative values.

        You may optionally pass in TextProperties to use for negative and

        positive amounts, respectively. If you don't, negative values will

        automatically be rendered in red (text color #f00).

        Results are cached. If you repeatedly call this method with the same

        arguments, you'll keep getting the same style returned, which will

        only be added to the document once.

        """

        if locale is None:

            locale = self.locale

        if negative_properties is None:

            negative_properties = odf.style.TextProperties(color='#ff0000')

        if root is None:

            root = self.document.styles

        cache_parts = [str(id(root)), code, str(locale)]

        for key, value in self.iter_attributes(negative_properties):

            cache_parts.append(f'{key}={value}')

        if positive_properties is not None:

            cache_parts.append('')

            for key, value in self.iter_attributes(positive_properties):

                cache_parts.append(f'{key}={value}')

        cache_key = '\0'.join(cache_parts)

        try:

            style = self._style_cache[cache_key]

        except KeyError:

            pos_style = self._build_currency_style(

                root, locale, code, 0, positive_properties, volatile=True,

            )

            curr_style = self._build_currency_style(

            )

            curr_style.addElement(odf.style.Map(

                condition='value()>=0', applystylename=pos_style,

            ))

            style = self.ensure_child(

                self.document.styles,

                odf.style.Style,

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

                family='table-cell',

                datastylename=curr_style,

            )

            self._style_cache[cache_key] = style

        return style

    def _merge_style_iter_names(

            self,

            styles: Sequence[Union[str, odf.style.Style, None]],

    ) -> Iterator[str]:

        for source in styles:

            if source is None:

                continue

            elif not isinstance(source, str):

                source = source.getAttribute('name')

            if source.startswith('Merge_'):

                orig_names = iter(source.split('_'))

                next(orig_names)

                yield from orig_names

            else:

                yield source

    def _merge_styles(self,

                      new_style: odf.style.Style,

                       generator: str='conservancy_beancount',

    ) -> None:

        if created is None:

            created = datetime.datetime.now()

        created_elem = self.ensure_child(self.document.meta, odf.meta.CreationDate)

        created_elem.childNodes.clear()

        created_elem.addText(created.isoformat())

        generator_elem = self.ensure_child(self.document.meta, odf.meta.Generator)

        generator_elem.childNodes.clear()

        generator_elem.addText(f'{generator}/{VERSION} {TOOLSVERSION}')

    ### 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:

        balance = balance.clean_copy() or balance

        balance_currency_count = len(balance)

        if balance_currency_count == 0:

            return self.float_cell(0, **attrs)

        elif balance_currency_count == 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:

            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

    def _meta_link_pairs(self, links: Iterable[Optional[str]]) -> Iterator[Tuple[str, str]]:

        for href in links:

            if href is None:

                continue

            elif self.rt_wrapper is not None:

                rt_ids = self.rt_wrapper.parse(href)

    The accounts are accounts in ``groups`` that appeared under one of the

    account name strings in ``order``. ``balance`` is the corresponding

    balance over the time period (``groups[key].period_bal``). Accounts are

    iterated in the order provided by ``sort_and_filter_accounts()``.

    The first 2-tuple is ``(OPENING_BALANCE_NAME, balance)`` with the balance of

    all these accounts as of ``start_date``.

    The final 2-tuple is ``(ENDING_BALANCE_NAME, balance)`` with the final

    balance of all these accounts as of ``start_date``.

    The iterator will always yield these special 2-tuples, even when there are

    no accounts in the input or to report.

    """

    if order is None:

        order = ['Equity', 'Income', 'Expenses']

    acct_seq = [account for _, account in sort_and_filter_accounts(groups, order)]

    yield (OPENING_BALANCE_NAME, sum(

        (groups[key].start_bal for key in acct_seq),

        MutableBalance(),

    ))

    for key in acct_seq:

        postings = groups[key]

        try:

            in_date_range = postings[-1].meta.date >= postings.START_DATE

        except IndexError:

            in_date_range = False

        if in_date_range:

            yield (key, groups[key].period_bal)

    yield (ENDING_BALANCE_NAME, sum(

        (groups[key].stop_bal for key in acct_seq),

        MutableBalance(),

    ))

def normalize_amount_func(account_name: str) -> Callable[[T], T]:

    """Get a function to normalize amounts for reporting

    Given an account name, return a function that can be used on "amounts"

    under that account (including numbers, Amount objects, and Balance objects)

    to normalize them for reporting. Right now that means make flipping the

    sign for accounts where "normal" postings are negative.

    """

    if account_name.startswith(('Assets:', 'Expenses:')):

        # We can't just return operator.pos because Beancount's Amount class

        # doesn't implement __pos__.

        return lambda amt: amt

    elif account_name.startswith(('Equity:', 'Income:', 'Liabilities:')):

        return operator.neg

    else:

        raise ValueError(f"unrecognized account name {account_name!r}")

def sort_and_filter_accounts(

        accounts: Iterable[data.Account],

        order: Sequence[str],

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

    """Reorganize accounts based on an ordered set of names

    This function takes a iterable of Account objects, and a sequence of

    account names. Usually the account names are higher parts of the account

    hierarchy like Income, Equity, or Assets:Receivable.

    It returns an iterator of 2-tuples, ``(index, account)`` where ``index`` is

    an index into the ordering sequence, and ``account`` is one of the input

    Account objects that's under the account name ``order[index]``. Tuples are

    sorted, so ``index`` increases monotonically, and Account objects using the

    same index are yielded sorted by name.

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

        'conservancy_beancount.tools',

    ],

    entry_points={

        'console_scripts': [

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

    assert row.lastChild is cell

def test_ods_writer_add_row_empty(ods_writer):

    row = ods_writer.add_row(stylename='blank')

    assert ods_writer.sheet.lastChild is row

    assert row.firstChild is None

    assert row.getAttribute('stylename') == 'blank'

def test_ods_writer_balance_cell_empty(ods_writer):

    balance = core.Balance()

    cell = ods_writer.balance_cell(balance)

    assert cell.value_type != 'string'

    assert float(cell.value) == 0

def test_ods_writer_balance_cell_single_currency(ods_writer):

    number = 250

    currency = 'EUR'

    balance = core.Balance([testutil.Amount(number, currency)])

    cell = ods_writer.balance_cell(balance)

    assert cell.value_type == 'currency'

    assert Decimal(cell.value) == number

    assert cell.text == babel.numbers.format_currency(

        number, currency, locale=EN_US, format_type='accounting',

    )

def test_ods_writer_balance_cell_multi_currency(ods_writer):

    amounts = [testutil.Amount(num, code) for num, code in [

        (2500, 'RUB'),

        (3500, 'BRL'),

    ]]

    balance = core.Balance(amounts)

    cell = ods_writer.balance_cell(balance)

@pytest.mark.parametrize('cell_source,style_name', testutil.combine_values(

    CURRENCY_CELL_DATA,

    XML_NAMES,

))

def test_ods_writer_currency_cell(ods_writer, cell_source, style_name):

    cell = ods_writer.currency_cell(cell_source, stylename=style_name)

    number, currency = cell_source

    assert cell.getAttribute('valuetype') == 'currency'

    assert cell.getAttribute('value') == str(number)

    assert cell.getAttribute('stylename') == style_name

    expected = babel.numbers.format_currency(

        number, currency, locale=EN_US, format_type='accounting',

    )

    assert get_text(cell) == expected

@pytest.mark.parametrize('currency', [

    'EUR',

    'CHF',

    'GBP',

])

def test_ods_writer_currency_cell_default_style(ods_writer, currency):

    amount = testutil.Amount(1000, currency)

    expected_stylename = ods_writer.currency_style(currency).getAttribute('name')

    cell = ods_writer.currency_cell(amount)

    assert cell.getAttribute('valuetype') == 'currency'

    assert cell.getAttribute('value') == '1000'

    assert cell.getAttribute('stylename') == expected_stylename

@pytest.mark.parametrize('date,style_name', testutil.combine_values(

    [datetime.date(1980, 2, 5), datetime.date(2030, 10, 30)],

    XML_NAMES_LIST,