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)

    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