new_style.addElement(self.copy_element(child))

    def merge_styles(self,

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

    ) -> Optional[odf.style.Style]:

        """Create a new style from multiple existing styles

        Given any number of existing styles, create a new style that combines

        all of those styles' attributes and properties, add it to the document

        styles, and return it.

        Styles can be specified by name, or by passing in their Style element.

        For convenience, you can also pass in None as an argument; None will

        simply be skipped.

        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 you pass in zero real style arguments, returns None.

        If you pass in one style argument, returns that style unchanged.

        If you pass in a style that doesn't already exist in the document,

        or if you pass in styles that can't be merged (because they have

        conflicting attributes), raises ValueError.

        """

        name_map: Dict[str, odf.style.Style] = {}

        for name in self._merge_style_iter_names(styles):

            source = odf.style.Style(name=name)

            found = self.find_child(self.document.styles, source)

            if found is None:

                raise ValueError(f"no style named {name!r}")

            name_map[name] = found

        if not name_map:

            retval = None

        elif len(name_map) == 1:

            _, retval = name_map.popitem()

        else:

            new_name = f'Merge_{"_".join(sorted(name_map))}'

            retval = self.ensure_child(

                self.document.styles, odf.style.Style, name=new_name,

            )

            if retval.firstChild is None:

                self._merge_styles(retval, name_map.values())

        return retval

    ### Sheets

    def lock_first_row(self, sheet: Optional[odf.table.Table]=None) -> None:

        """Lock the first row of cells under the given sheet

        This method sets all the appropriate settings to "lock" the first row

        of cells in a sheet, so it stays in view even as the viewer scrolls

        through rows. If a sheet is not given, works on ``self.sheet``.

        """

        if sheet is None:

            sheet = self.sheet

        config_map = self.ensure_config_map_entry(

            self.view, 'Tables', sheet.getAttribute('name'),

        )

        self.set_config(config_map, 'PositionBottom', 1, 'int')

        self.set_config(config_map, 'VerticalSplitMode', 2, 'short')

        self.set_config(config_map, 'VerticalSplitPosition', 1, 'short')

    def use_sheet(self, name: str) -> odf.table.Table:

        """Switch the active sheet ``self.sheet`` to the one with the given name

        If there is no sheet with the given name, create it and append it to

        the spreadsheet first.

        If the current active sheet is empty when this method is called, it

        will be removed from the spreadsheet.

        """

        try:

            empty_sheet = not self.sheet.hasChildNodes()

        except AttributeError:

            empty_sheet = False

        if empty_sheet:

            self.document.spreadsheet.removeChild(self.sheet)

        self.sheet = self.ensure_child(

            self.document.spreadsheet, odf.table.Table, name=name,

        )

        return self.sheet

    ### Initialization hooks

    def init_settings(self) -> None:

        """Hook called to initialize settings

        This method is called by __init__ to populate

        ``self.document.settings``. This implementation creates the barest

        skeleton structure necessary to support other methods, in particular

        ``lock_first_row``.

        """

        view_settings = self.ensure_child(

            self.document.settings, odf.config.ConfigItemSet, name='ooo:view-settings',

        )

        views = self.ensure_child(

            view_settings, odf.config.ConfigItemMapIndexed, name='Views',

        )

        self.view = self.ensure_child(views, odf.config.ConfigItemMapEntry)

        self.set_config(self.view, 'ViewId', 'view1')

    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)

        self.style_col1: odf.style.Style

        self.style_col1_25: odf.style.Style

        self.style_col1_5: odf.style.Style

        self.style_col1_75: odf.style.Style

        self.style_col2: odf.style.Style

        for width in ['1', '1.25', '1.5', '1.75', '2']:

            width_name = width.replace('.', '_')

            column_style = self.replace_child(

                self.document.automaticstyles, odf.style.Style, name=f'col_{width_name}',

            )

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

            column_style.addElement(odf.style.TableColumnProperties(columnwidth=f'{width}in'))

            setattr(self, f'style_col{width_name}', column_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:

        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)

                rt_href = rt_ids and self.rt_wrapper.url(*rt_ids)

            else:

                rt_ids = None

                rt_href = None

            if rt_ids is None or rt_href is None:

                # '..' pops the ODS filename off the link path. In other words,

                # make the link relative to the directory the ODS is in.

                href_path = Path('..', href)

                href = str(href_path)

                text = href_path.name

            else:

                rt_path = urlparse.urlparse(rt_href).path

                if rt_path.endswith('/Ticket/Display.html'):

                    text = rtutil.RT.unparse(*rt_ids)

                else:

                    text = urlparse.unquote(Path(rt_path).name)

                href = rt_href

            yield (href, text)

    def meta_links_cell(self, links: Iterable[Optional[str]], **attrs: Any) -> odf.table.TableCell:

        return self.multilink_cell(self._meta_link_pairs(links), **attrs)

    def multiline_cell(self, lines: Iterable[Any], **attrs: Any) -> odf.table.TableCell:

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

        for line in lines:

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

        return cell

    def multilink_cell(self, links: Iterable[LinkType], **attrs: Any) -> odf.table.TableCell:

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

        for link in links:

            if isinstance(link, tuple):

                href, text = link

            else:

                href = link

                text = None

            cell.addElement(odf.text.P())

            cell.lastChild.addElement(odf.text.A(

                type='simple', href=href, text=text or href,

            ))

        return cell

    def string_cell(self, text: str, **attrs: Any) -> odf.table.TableCell:

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

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

        return cell

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

        """Write a single row of input data to the spreadsheet

        This default implementation adds a single row to the spreadsheet,

        with one cell per element of the row. The type of each element

        determines what kind of cell is created.

        This implementation will help get you started, but you'll probably

        want to override it to specify styles.

        """

        out_row = odf.table.TableRow()

        for cell_source in row:

            if isinstance(cell_source, (int, float, Decimal)):

                cell = self.float_cell(cell_source)

            else:

                cell = self.string_cell(cell_source)

            out_row.addElement(cell)

        self.sheet.addElement(out_row)

    def save_file(self, out_file: BinaryIO) -> None:

        self.document.write(out_file)

    def save_path(self, path: Path, mode: str='w') -> None:

        with path.open(f'{mode}b') as out_file:

            out_file = cast(BinaryIO, out_file)

            self.save_file(out_file)

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

    actual = get_child(root, odf.style.Style, name=style.getAttribute('name'))

    assert actual is style

    child = get_child(actual, child_type)

    assert child.getAttribute(checked_attr)

def test_ods_writer_merge_styles(ods_writer):

    style = ods_writer.merge_styles(ods_writer.style_bold, ods_writer.style_dividerline)

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style.getAttribute('name'),

    )

    assert actual is style

    assert actual.getAttribute('family') == 'table-cell'

    text_props = get_child(actual, odf.style.TextProperties)

    assert text_props.getAttribute('fontweight') == 'bold'

    cell_props = get_child(actual, odf.style.TableCellProperties)

    assert cell_props.getAttribute('borderbottom')

def test_ods_writer_merge_styles_with_children_and_attributes(ods_writer):

    jpy_style = ods_writer.currency_style('JPY')

    style = ods_writer.merge_styles(ods_writer.style_bold, jpy_style)

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style.getAttribute('name'),

    )

    assert actual is style

    assert actual.getAttribute('family') == 'table-cell'

    assert actual.getAttribute('datastylename') == jpy_style.getAttribute('datastylename')

    text_props = get_child(actual, odf.style.TextProperties)

    assert text_props.getAttribute('fontweight') == 'bold'

def test_ods_writer_merge_styles_caches(ods_writer):

    sources = [ods_writer.style_bold, ods_writer.style_dividerline]

    style1 = ods_writer.merge_styles(*sources)

    style2 = ods_writer.merge_styles(*reversed(sources))

    assert style1 is style2

    assert get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style1.getAttribute('name'),

    )

def test_ods_writer_layer_merge_styles(ods_writer):

    usd_style = ods_writer.currency_style('USD')

    layer1 = ods_writer.merge_styles(ods_writer.style_bold, ods_writer.style_dividerline)

    layer2 = ods_writer.merge_styles(layer1, usd_style)

    style_name = layer2.getAttribute('name')

    assert style_name.count('Merge_') == 1

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        name=style_name,

    )

    assert actual is layer2

    assert actual.getAttribute('family') == 'table-cell'

    assert actual.getAttribute('datastylename') == usd_style.getAttribute('datastylename')

    text_props = get_child(actual, odf.style.TextProperties)

    assert text_props.getAttribute('fontweight') == 'bold'

    cell_props = get_child(actual, odf.style.TableCellProperties)

    assert cell_props.getAttribute('borderbottom')

def test_ods_writer_merge_one_style(ods_writer):

    actual = ods_writer.merge_styles(None, ods_writer.style_bold)

    assert actual is ods_writer.style_bold

def test_ods_writer_merge_no_styles(ods_writer):

    assert ods_writer.merge_styles() is None

def test_ods_writer_merge_nonexistent_style(ods_writer):

    name = 'Non Existent Style'

    with pytest.raises(ValueError, match=repr(name)):

        ods_writer.merge_styles(ods_writer.style_bold, name)

def test_ods_writer_merge_conflicting_styles(ods_writer):

    sources = [ods_writer.currency_style(code) for code in ['USD', 'EUR']]

    with pytest.raises(ValueError, match='conflicting datastylename'):

        ods_writer.merge_styles(*sources)

def test_ods_writer_date_style(ods_writer):

    data_style_name = ods_writer.style_date.getAttribute('datastylename')

    actual = get_child(

        ods_writer.document.styles,

        odf.style.Style,

        family='table-cell',

        datastylename=data_style_name,

    )

    assert actual is ods_writer.style_date

    data_style = get_child(

        ods_writer.document.styles,

        odf.number.DateStyle,

        name=data_style_name,

    )

    assert len(data_style.childNodes) == 5

    year, t1, month, t2, day = data_style.childNodes

    assert year.qname[1] == 'year'

    assert year.getAttribute('style') == 'long'

    assert get_text(t1) == '-'

    assert month.qname[1] == 'month'

    assert month.getAttribute('style') == 'long'

    assert get_text(t2) == '-'

    assert day.qname[1] == 'day'

    assert day.getAttribute('style') == 'long'

def test_ods_lock_first_row(ods_writer):

    ods_writer.lock_first_row()

    view_settings = get_child(

        ods_writer.document.settings,

        odf.config.ConfigItemSet,

        name='ooo:view-settings',

    )

    views = get_child(view_settings, odf.config.ConfigItemMapIndexed, name='Views')

    view1 = get_child(views, odf.config.ConfigItemMapEntry, index=0)

    config_map = get_child(view1, odf.config.ConfigItemMapNamed, name='Tables')

    sheet_name = ods_writer.sheet.getAttribute('name')

    config_entry = get_child(config_map, odf.config.ConfigItemMapEntry, name=sheet_name)

    for name, ctype, value in [

            ('PositionBottom', 'int', '1'),

            ('VerticalSplitMode', 'short', '2'),

            ('VerticalSplitPosition', 'short', '1'),

    ]:

        child = get_child(config_entry, odf.config.ConfigItem, name=name)

        assert child.getAttribute('type') == ctype

        assert child.firstChild.data == value

@pytest.mark.parametrize('style_name', XML_NAMES_LIST)

def test_ods_writer_add_row(ods_writer, style_name):

    cell1 = ods_writer.string_cell('one')

    cell2 = ods_writer.float_cell(42.0)

    row = ods_writer.add_row(cell1, cell2, defaultcellstylename=style_name)

    assert ods_writer.sheet.lastChild is row

    assert row.getAttribute('defaultcellstylename') == style_name

    assert row.firstChild is cell1

    assert row.lastChild is cell2

def test_ods_writer_add_row_single_cell(ods_writer):

    cell = ods_writer.multilink_cell(LINK_CELL_DATA[:1])

    row = ods_writer.add_row(cell)

    assert ods_writer.sheet.lastChild is row

    assert row.firstChild is cell

    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)

    assert cell.text == '\0'.join(babel.numbers.format_currency(

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

    ) for number, currency in amounts)

@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('date,style_name', testutil.combine_values(

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

    XML_NAMES_LIST,

))

def test_ods_writer_date_cell(ods_writer, date, style_name):

    if style_name is None:

        expect_style = ods_writer.style_date.getAttribute('name')

        cell = ods_writer.date_cell(date)

    else:

        expect_style = style_name

        cell = ods_writer.date_cell(date, stylename=style_name)

    date_s = date.isoformat()

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

    assert cell.getAttribute('datevalue') == date_s

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

    assert get_text(cell) == date_s

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

    NUMERIC_CELL_DATA,

    XML_NAMES,

))

def test_ods_writer_float_cell(ods_writer, cell_source, style_name):

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

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

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

    expected = str(cell_source)

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

    assert get_text(cell) == expected

def test_ods_writer_meta_links_cell(ods_writer):

    rt_client = testutil.RTClient()

    ods_writer.rt_wrapper = rtutil.RT(rt_client)

    rt_url = rt_client.DEFAULT_URL[:-10]

    meta_links = [

        'rt://ticket/1',

        'rt://ticket/2/attachments/9',

        'rt:1/5',

        'Invoices/0123.pdf',

    ]

    cell = ods_writer.meta_links_cell(meta_links, stylename='meta1')

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

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

    children = iter(get_children(cell, odf.text.A))

    child = next(children)

    assert child.getAttribute('type') == 'simple'

    expect_url = f'{rt_url}/Ticket/Display.html?id=1'

    assert child.getAttribute('href') == expect_url

    assert get_text(child) == 'rt:1'

    child = next(children)

    assert child.getAttribute('type') == 'simple'

    expect_url = f'{rt_url}/Ticket/Display.html?id=2#txn-7'

    assert child.getAttribute('href') == expect_url

    assert get_text(child) == 'rt:2/9'

    child = next(children)

    assert child.getAttribute('type') == 'simple'

    expect_url = f'{rt_url}/Ticket/Attachment/1/5/photo.jpg'

    assert child.getAttribute('href') == expect_url

    assert get_text(child) == 'photo.jpg'

    child = next(children)

    assert child.getAttribute('type') == 'simple'

    expect_url = f'../{meta_links[3]}'

    assert child.getAttribute('href') == expect_url

    assert get_text(child) == '0123.pdf'

def test_ods_writer_multiline_cell(ods_writer):

    cell = ods_writer.multiline_cell(iter(STRING_CELL_DATA))

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

    children = get_children(cell, odf.text.P)

    for expected, child in itertools.zip_longest(STRING_CELL_DATA, children):

        assert get_text(child) == expected

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

    LINK_CELL_DATA,

    XML_NAMES,

))

def test_ods_writer_multilink_singleton(ods_writer, cell_source, style_name):

    cell = ods_writer.multilink_cell([cell_source], stylename=style_name)

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

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

    try:

        href, text = cell_source

    except ValueError:

        href = cell_source

        text = None

    anchor = get_child(cell, odf.text.A, type='simple', href=href)

    assert get_text(anchor) == (text or href)

def test_ods_writer_multilink_cell(ods_writer):

    cell = ods_writer.multilink_cell(iter(LINK_CELL_DATA))

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

    children = get_children(cell, odf.text.A)

    for source, child in itertools.zip_longest(LINK_CELL_DATA, children):

        try:

            href, text = source

        except ValueError:

            href = source

            text = None

        assert child.getAttribute('type') == 'simple'

        assert child.getAttribute('href') == href

        assert get_text(child) == (text or href)

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

    STRING_CELL_DATA,

    XML_NAMES,

))

def test_ods_writer_string_cell(ods_writer, cell_source, style_name):

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

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

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

    assert get_text(cell) == str(cell_source)