git_shahex = '<none>'

            git_dirty = True

        else:

            git_shahex = repo.head.commit.hexsha

            git_dirty = repo.is_dirty()

        self.set_custom_property('GitSHA', git_shahex)

        self.set_custom_property('GitDirty', git_dirty, 'boolean')

        if command is not None:

            command_s = ' '.join(shlex.quote(s) for s in command)

            self.set_custom_property('ReportCommand', command_s)

    def set_custom_property(self,

                            name: str,

                            value: Any,

                            valuetype: Optional[str]=None,

    ) -> odf.meta.UserDefined:

        if valuetype is None:

            if isinstance(value, bool):

                valuetype = 'boolean'

            elif isinstance(value, (datetime.date, datetime.datetime)):

                valuetype = 'date'

            elif isinstance(value, (int, float, Decimal)):

                valuetype = 'float'

        if not isinstance(value, str):

            if valuetype == 'boolean':

                value = 'true' if value else 'false'

            elif valuetype == 'date':

                value = value.isoformat()

            else:

                value = str(value)

        retval = self.ensure_child(self.document.meta, odf.meta.UserDefined, name=name)

        if valuetype is None:

            try:

                retval.removeAttribute('valuetype')

            except KeyError:

                pass

        else:

            retval.setAttribute('valuetype', valuetype)

        retval.childNodes.clear()

        retval.addText(value)

        return retval

    def set_properties(self, *,

                       created: Optional[datetime.datetime]=None,

                       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}/{cliutil.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:

            lines = [babel.numbers.format_currency(number, currency, get_commodity_format(

                self.locale, currency, None, 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

    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 = urlparse.quote(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

    ('lock_first_column', 'Horizontal', 'Right'),

])

def test_ods_lock_first_cells(ods_writer, method_name, split_name, side_name):

    getattr(ods_writer, method_name)()

    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 [

            (f'Position{side_name}', 'int', '1'),

            (f'{split_name}SplitMode', 'short', '2'),

            (f'{split_name}SplitPosition', '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('arg', [

    None,

    'Target Sheet',

    odf.table.Table(name='Target Sheet'),

])

def test_ods_set_open_sheet(ods_writer, arg):

    ods_writer.use_sheet('Start Sheet' if arg else 'Target Sheet')

    ods_writer.set_open_sheet(arg)

    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)

    actual = get_child(view1, odf.config.ConfigItem, name='ActiveTable')

    assert actual.text == 'Target Sheet'

@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 == '2,500.00 RUB\0R$3,500.00'

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

))

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