def test_parse_cals_colspec(attrib, styles, nature):
# --without namespaces
cals_colspec = etree.Element("colspec", attrib=attrib)
parser = CalsParser(BaseBuilder())
parser.setup_table()
state = parser._state
state.next_col()
state = parser.parse_cals_colspec(cals_colspec)
col_pos = int(attrib.get("colnum", 1))
col = state.table.cols[col_pos]
assert col.styles == styles
assert col.nature == nature
# --with default namespaces
cals_colspec_attrib = {cals(k): v for k, v in attrib.items()}
cals_colspec = etree.Element(cals("colspec"),
attrib=cals_colspec_attrib,
nsmap={None: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
parser.setup_table()
state = parser._state
state.next_col()
state = parser.parse_cals_colspec(cals_colspec)
col_pos = int(attrib.get("colnum", 1))
col = state.table.cols[col_pos]
assert col.styles == styles
assert col.nature == nature
def test_parse_cals_table(attrib, styles, nature):
# --without namespaces
cals_table = etree.Element("table", attrib=attrib)
parser = CalsParser(BaseBuilder())
state = parser.parse_cals_table(cals_table)
table = state.table
assert table.styles == styles
assert table.nature == nature
# --with default namespaces
cals_table_attrib = {cals(k): v for k, v in attrib.items()}
cals_table = etree.Element(cals("table"),
attrib=cals_table_attrib,
nsmap={None: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
state = parser.parse_cals_table(cals_table)
table = state.table
assert table.styles == styles
assert table.nature == nature
# --with namespaces prefix
cals_table_attrib = {cals(k): v for k, v in attrib.items()}
cals_table = etree.Element(cals("table"),
attrib=cals_table_attrib,
nsmap={CALS_PREFIX: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
state = parser.parse_cals_table(cals_table)
table = state.table
assert table.styles == styles
assert table.nature == nature
def test_parse_cals_entry(attrib, styles, nature):
# --without namespaces
cals_entry = etree.Element("entry", attrib=attrib)
parser = CalsParser(BaseBuilder())
parser.setup_table()
state = parser._state
state.next_row()
state.row = state.table.rows[state.row_pos]
state.next_col()
state = parser.parse_cals_entry(cals_entry)
cell = state.table[(1, 1)]
assert cell.styles == styles
assert cell.nature == nature
# --with default namespaces
cals_entry_attrib = {cals(k): v for k, v in attrib.items()}
cals_entry = etree.Element(cals("entry"),
attrib=cals_entry_attrib,
nsmap={None: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
parser.setup_table()
state = parser._state
state.next_row()
state.row = state.table.rows[state.row_pos]
state.next_col()
state = parser.parse_cals_entry(cals_entry)
cell = state.table[(1, 1)]
assert cell.styles == styles
assert cell.nature == nature
def test_parse_table():
# fmt: off
E = ElementMaker()
cals_table = E.table(
E.titles("titles"),
E.tgroup(
E.colspec(),
E.colspec(),
E.thead(E.row(E.entry("Col A"), E.entry("Col B"))),
E.tfoot(E.row(E.entry("Foot notes", namest="c1", nameend="c2"))),
E.tbody(E.row(E.entry("A1"), E.entry("B1")),
E.row(E.entry("A2"), E.entry("B2"))),
),
)
parser = CalsParser(BaseBuilder())
table = parser.parse_table(cals_table)
assert len(table.cols) == 2
assert len(table.rows) == 4
assert str(table) == textwrap.dedent("""\
+-----------+-----------+
| Col A | Col B |
+-----------------------+
| Foot note |
+-----------+-----------+
| A1 | B1 |
+-----------+-----------+
| A2 | B2 |
+-----------+-----------+""")
def test_parse_cals_tgroup__overrides_table():
# --without namespaces
parser = CalsParser(BaseBuilder())
parser.setup_table(
{
"x-cell-border-right": BORDER_NONE,
"x-cell-border-bottom": BORDER_NONE,
"x-sect-orient": "landscape",
"x-sect-cols": "1",
"background-color": "velvet",
},
"TableOld",
)
cals_tgroup_attrib = {
"colsep": "1",
"rowsep": "1",
"tgroupstyle": "TableNew"
}
cals_tgroup = etree.Element("tgroup", attrib=cals_tgroup_attrib)
state = parser.parse_cals_tgroup(cals_tgroup)
table = state.table
assert table.styles == {
"x-cell-border-right": BORDER_SOLID,
"x-cell-border-bottom": BORDER_SOLID,
"x-sect-orient": "landscape", # preserved
"x-sect-cols": "1", # preserved
"background-color": "velvet", # preserved
}
assert table.nature == "TableNew"
def test_parse_fmx_sti_blk__level1():
fmx_blk = etree.Element("BLK")
fmx_sti_blk = etree.XML(
"""<STI.BLK COL.START="2" COL.END="2" valign="top" rowsep="1" bgcolor="blue">text</STI.BLK>"""
)
fmx_blk.append(fmx_sti_blk)
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
state.next_row()
state = parser.parse_fmx_sti_blk(fmx_sti_blk)
row = state.row
assert row.styles == {
'background-color': 'blue',
'border-bottom': 'solid 1pt black',
'rowstyle': 'STI.BLK-level1',
'vertical-align': 'top',
}
assert row.nature == "body"
table = state.table
cell1 = table[(1, 1)]
assert cell1.content is None
cell2 = table[(2, 1)]
assert cell2.styles == {}
assert cell2.nature == "body"
assert cell2.width == 1
assert cell2.height == 1
assert cell2.content[0] == "text"
def test_parse_fmx_cell__with_cals():
E = ElementMaker()
fmx_cell = E.CELL(
colsep="1",
rowsep="1",
namest="c1",
nameend="c3",
bgcolor="#00007f",
morerows="1",
align="center",
valign="middle",
)
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
state.next_row()
state.row = state.table.rows[state.row_pos]
parser.parse_fmx_cell(fmx_cell)
table = state.table
cell = table[(1, 1)]
assert cell.styles == {
'align': 'center',
'background-color': '#00007f',
'vertical-align': 'middle',
'x-cell-border-bottom': 'solid 1pt black',
'x-cell-border-right': 'solid 1pt black',
}
assert cell.nature is None
assert cell.size == (3, 2)
def test_parse_fmx_ti_blk__level2__with_namespace():
def fmx(name):
return etree.QName(FORMEX_NS, name).text
BLK = fmx("BLK")
TI_BLK = fmx("TI.BLK")
IE = fmx("IE")
fmx_blk1 = etree.Element(BLK, nsmap={None: FORMEX_NS})
fmx_blk2 = etree.SubElement(fmx_blk1, BLK, nsmap={None: FORMEX_NS})
fmx_ti_blk = etree.SubElement(fmx_blk2, TI_BLK, nsmap={None: FORMEX_NS})
etree.SubElement(fmx_ti_blk, IE, nsmap={None: FORMEX_NS})
parser = FormexParser(BaseBuilder(),
formex_ns=FORMEX_NS,
cals_prefix=CALS_PREFIX,
cals_ns=CALS_NS)
state = parser.setup_table()
state.next_row()
state = parser.parse_fmx_ti_blk(fmx_ti_blk)
row = state.row
assert row.styles == {"rowstyle": "TI.BLK-level2"}
assert row.nature == "body"
table = state.table
cell = table[(1, 1)]
assert cell.styles == {}
assert cell.nature == "body"
assert cell.width == 1
assert cell.height == 1
assert cell.content == ""
def test_parse_fmx_ti_blk__level1():
fmx_blk = etree.Element("BLK")
fmx_ti_blk = etree.XML(
"""<TI.BLK COL.START="1" COL.END="2" valign="top" rowsep="1" bgcolor="blue"><P>paragraph</P></TI.BLK>"""
)
fmx_blk.append(fmx_ti_blk)
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
state.next_row()
state = parser.parse_fmx_ti_blk(fmx_ti_blk)
row = state.row
assert row.styles == {
'background-color': 'blue',
'border-bottom': 'solid 1pt black',
'rowstyle': 'TI.BLK-level1',
'vertical-align': 'top',
}
assert row.nature == "body"
table = state.table
cell = table[(1, 1)]
assert cell.styles == {}
assert cell.nature == "body"
assert cell.width == 2
assert cell.height == 1
assert etree.tounicode(cell.content[0]) == "<P>paragraph</P>"
def test_parse_fmx_tbl_corpus(attrib, styles, nature):
fmx_tbl = etree.Element("TBL", attrib=attrib)
fmx_corpus = etree.SubElement(fmx_tbl, "CORPUS")
parser = FormexParser(BaseBuilder())
state = parser.parse_fmx_corpus(fmx_corpus)
table = state.table
assert table.styles == styles
assert table.nature == nature
def test_parse_cals_row__nature_from_parent(tag, nature):
# --without namespaces
cals_parent = etree.Element(tag)
cals_row = etree.SubElement(cals_parent, "row")
parser = CalsParser(BaseBuilder())
parser.setup_table()
parser._state.next_row()
state = parser.parse_cals_row(cals_row)
row = state.table.rows[1]
assert row.nature == nature
def test_parse_cals_row__overrides_parent_valign():
# --without namespaces
cals_tbody = etree.Element("tbody", valign="top")
cals_row = etree.SubElement(cals_tbody, "row", valign="middle")
parser = CalsParser(BaseBuilder())
parser.setup_table()
parser._state.next_row()
state = parser.parse_cals_row(cals_row)
row = state.table.rows[1]
assert row.styles["vertical-align"] == "middle"
def test_parse_fmx_colspec(attrib, styles, nature):
cals_colspec = etree.Element("colspec", attrib=attrib)
parser = FormexParser(BaseBuilder())
parser.setup_table()
state = parser._state
state.next_col()
state = parser.parse_fmx_colspec(cals_colspec)
col_pos = int(attrib.get("colnum", 1))
col = state.table.cols[col_pos]
assert col.styles == styles
assert col.nature == nature
def test_parse_fmx_row(attrib, styles, nature):
E = ElementMaker()
fmx_row = E.ROW(**attrib)
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
state.next_row()
state.row = state.table.rows[state.row_pos]
state = parser.parse_fmx_row(fmx_row)
row = state.row
assert row.styles == styles
assert row.nature == nature
def test_parse_cals_tgroup(attrib, styles, nature):
# --without namespaces
cals_tgroup = etree.Element("tgroup", attrib=attrib)
parser = CalsParser(BaseBuilder())
parser.setup_table()
state = parser.parse_cals_tgroup(cals_tgroup)
table = state.table
assert table.styles == styles
assert table.nature == nature
# --with default namespaces
cals_tgroup_attrib = {cals(k): v for k, v in attrib.items()}
cals_tgroup = etree.Element(cals("tgroup"),
attrib=cals_tgroup_attrib,
nsmap={None: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
parser.setup_table()
state = parser.parse_cals_tgroup(cals_tgroup)
table = state.table
assert table.styles == styles
assert table.nature == nature
def test_parse_cals_entry__spanning(attrib, size):
# --without namespaces
cals_entry = etree.Element("entry", attrib=attrib)
parser = CalsParser(BaseBuilder())
parser.setup_table()
state = parser._state
state.next_row()
state.row = state.table.rows[state.row_pos]
state.next_col()
state = parser.parse_cals_entry(cals_entry)
cell = state.table[(1, 1)]
assert cell.size == size
def test_parse_fmx_cell(attrib, styles, nature, size):
E = ElementMaker()
fmx_cell = E.CELL(**attrib)
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
state.next_row()
state.row = state.table.rows[state.row_pos]
parser.parse_fmx_cell(fmx_cell)
table = state.table
cell = table[(1, 1)]
assert cell.styles == styles
assert cell.nature == nature
assert cell.size == size
def test_parse_cals_entry(attrib, styles, nature):
# --without namespaces
cals_entry = etree.Element("entry", attrib=attrib)
parser = CalsParser(BaseBuilder())
parser.setup_table()
state = parser._state
state.next_row()
state.row = state.table.rows[state.row_pos]
state.next_col()
state = parser.parse_cals_entry(cals_entry)
cell = state.table[(1, 1)]
# Ignore cell styles extensions (like 'x-cell-empty').
actual = {
k: v
for k, v in cell.styles.items() if not k.startswith("x-cell-")
}
assert actual == styles
assert cell.nature == nature
# --with default namespaces
cals_entry_attrib = {cals(k): v for k, v in attrib.items()}
cals_entry = etree.Element(cals("entry"),
attrib=cals_entry_attrib,
nsmap={None: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
parser.setup_table()
state = parser._state
state.next_row()
state.row = state.table.rows[state.row_pos]
state.next_col()
state = parser.parse_cals_entry(cals_entry)
cell = state.table[(1, 1)]
# Ignore cell styles extensions (like 'x-cell-empty').
actual = {
k: v
for k, v in cell.styles.items() if not k.startswith("x-cell-")
}
assert actual == styles
assert cell.nature == nature
def test_parse_cals_row(attrib, styles, nature):
# --without namespaces
cals_row = etree.Element("row", attrib=attrib)
parser = CalsParser(BaseBuilder())
parser.setup_table()
parser._state.next_row()
state = parser.parse_cals_row(cals_row)
row = state.table.rows[1]
assert row.styles == styles
assert row.nature == nature
# --with default namespaces
cals_row_attrib = {cals(k): v for k, v in attrib.items()}
cals_row = etree.Element(cals("row"),
attrib=cals_row_attrib,
nsmap={None: CALS_NS})
parser = CalsParser(BaseBuilder(), cals_ns=CALS_NS)
parser.setup_table()
parser._state.next_row()
state = parser.parse_cals_row(cals_row)
row = state.table.rows[1]
assert row.styles == styles
assert row.nature == nature
def test_parse_tc(w_tc_content, expected):
builder = BaseBuilder()
parser = OoxmlParser(builder)
# -- setup a minimal table
state = parser._state
state.table = Table()
state.row = state.table.rows[1]
state.next_col()
# -- parse a <w:tc/>
w_tc = etree.XML(w_tc_content)
parser.parse_tc(w_tc)
# -- check the styles
table = state.table
cell = table[(1, 1)]
assert expected == cell.styles
def test_parse_fmx_ti_blk__level2():
fmx_blk = etree.Element("BLK")
fmx_blk = etree.SubElement(fmx_blk, "BLK")
fmx_ti_blk = etree.XML("""<TI.BLK><IE/></TI.BLK>""")
fmx_blk.append(fmx_ti_blk)
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
state.next_row()
state = parser.parse_fmx_ti_blk(fmx_ti_blk)
row = state.row
assert row.styles == {"rowstyle": "TI.BLK-level2"}
assert row.nature == "body"
table = state.table
cell = table[(1, 1)]
assert cell.styles == {}
assert cell.nature == "body"
assert cell.width == 1
assert cell.height == 1
assert cell.content == ""
def test_parse_fmx_gr_notes():
# fmt: off
fmx_gr_notes = etree.XML("""\
<GR.NOTES valign="top" rowsep="1" bgcolor="blue">
<TITLE><TI><P>GR.NOTES Title</P></TI></TITLE>
<NOTE NOTE.ID="N0001"><P>Table note</P></NOTE>
</GR.NOTES>""")
# fmt: on
parser = FormexParser(BaseBuilder())
state = parser.setup_table()
# -- insert at least one ROW for testing
state.next_row()
state.row = state.table.rows[state.row_pos]
state.row.insert_cell("text1")
state.row.insert_cell("text2")
state.row.insert_cell("text3")
# -- then add the footer
state.next_row()
state = parser.parse_gr_notes(fmx_gr_notes)
row = state.row
assert row.styles == {}
assert row.nature == "footer"
# -- the cell is in the row 2
cell = state.table[(1, 2)]
assert cell.styles == {
'background-color': 'blue',
'border-bottom': 'solid 1pt black',
'vertical-align': 'top'
}
assert cell.nature == "footer"
assert cell.width == 3
assert cell.height == 1
content = [
node for node in cell.content if isinstance(node, etree._Element)
]
assert etree.tounicode(
content[0],
with_tail=False) == "<TITLE><TI><P>GR.NOTES Title</P></TI></TITLE>"
assert etree.tounicode(
content[1],
with_tail=False) == '<NOTE NOTE.ID="N0001"><P>Table note</P></NOTE>'
def test_parse_tc(w_tc_content, expected):
builder = BaseBuilder()
parser = OoxmlParser(builder)
# -- setup a minimal table
state = parser._state
state.table = Table()
state.row = state.table.rows[1]
state.next_col()
# -- parse a <w:tc/>
w_tc = etree.XML(w_tc_content)
parser.parse_tc(w_tc)
# -- check the styles
table = state.table
cell = table[(1, 1)]
# Ignore cell styles extensions (like 'x-cell-empty').
actual = {
k: v
for k, v in cell.styles.items() if not k.startswith("x-cell-")
}
assert expected == actual
def test_init__options(self):
builder = BaseBuilder(key="value")
assert builder.options == {"key": "value"}
def test_contains_ie(content, expected):
fmx_node = etree.XML(content)
parser = FormexParser(BaseBuilder())
assert parser.contains_ie(fmx_node) is expected
def test_append_content(elements, expected):
builder = BaseBuilder()
cell_elem = etree.Element(u"cell")
builder.append_cell_elements(cell_elem, elements)
assert etree.tounicode(cell_elem) == expected
def test_parse_fmx_corpus(attrib, styles):
fmx_corpus = etree.Element("CORPUS", attrib=attrib)
parser = FormexParser(BaseBuilder())
state = parser.parse_fmx_corpus(fmx_corpus)
table = state.table
assert table.styles == styles
def test_contains_ie__with_formex_ns(content, expected):
fmx_node = etree.XML(content)
parser = FormexParser(BaseBuilder(), formex_ns="http://opoce")
assert parser.contains_ie(fmx_node) is expected
def test_setup_table():
parser = CalsParser(BaseBuilder())
state = parser.setup_table({"key": "value"}, nature="something")
assert state.table is not None
assert state.table.styles == {"key": "value"}
assert state.table.nature == "something"
def setUp(self):
self.builder = BaseBuilder()
