From 8fa1fcd70c807dfae3de83e52c273857e6a9db50 Mon Sep 17 00:00:00 2001 From: Michael Williamson Date: Sat, 4 Jul 2015 13:22:27 +0100 Subject: Split body reading from document reading --- mammoth/docx/body_xml.py | 356 ++++++++++++++++++++++++++++ mammoth/docx/document_xml.py | 347 +-------------------------- tests/docx/body_xml_tests.py | 494 +++++++++++++++++++++++++++++++++++++++ tests/docx/document_xml_tests.py | 463 +----------------------------------- 4 files changed, 859 insertions(+), 801 deletions(-) create mode 100644 mammoth/docx/body_xml.py create mode 100644 tests/docx/body_xml_tests.py diff --git a/mammoth/docx/body_xml.py b/mammoth/docx/body_xml.py new file mode 100644 index 0000000..cb42f05 --- /dev/null +++ b/mammoth/docx/body_xml.py @@ -0,0 +1,356 @@ +import contextlib + +from .. import documents +from .. import results +from .. import lists +from .xmlparser import node_types + + +def reader(numbering=None, + content_types=None, + relationships=None, + styles=None, + docx_file=None): + + read, read_all = _create_reader( + numbering=numbering, + content_types=content_types, + relationships=relationships, + styles=styles, + docx_file=docx_file, + ) + return _BodyReader(read, read_all) + + + +class _BodyReader(object): + def __init__(self, read, read_all): + self._read = read + self._read_all = read_all + + def read(self, element): + result = self._read(element) + return results.Result(result.value, result.messages) + + def read_all(self, elements): + result = self._read_all(elements) + return results.Result(result.value, result.messages) + + +def _create_reader(numbering, content_types, relationships, styles, docx_file): + _handlers = {} + _ignored_elements = set([ + "w:bookmarkStart", + "w:bookmarkEnd", + "w:sectPr", + "w:proofErr", + "w:lastRenderedPageBreak", + "w:commentRangeStart", + "w:commentRangeEnd", + "w:commentReference", + "w:del", + "w:footnoteRef", + "w:endnoteRef", + "w:pPr", + "w:rPr", + "w:tblPr", + "w:tblGrid", + "w:tcPr", + ]) + + def handler(name): + def add(func): + _handlers[name] = func + return func + + return add + + @handler("w:t") + def text(element): + return _success(documents.Text(_inner_text(element))) + + + @handler("w:r") + def run(element): + properties = element.find_child_or_null("w:rPr") + style_id = properties \ + .find_child_or_null("w:rStyle") \ + .attributes.get("w:val") + + if style_id is None: + style_name = None + else: + style_name = styles.find_character_style_by_id(style_id).name + + vertical_alignment = properties \ + .find_child_or_null("w:vertAlign") \ + .attributes.get("w:val") + + is_bold = properties.find_child("w:b") + is_italic = properties.find_child("w:i") + is_underline = properties.find_child("w:u") + is_strikethrough = properties.find_child("w:strike") + + return _read_xml_elements(element.children) \ + .map(lambda children: documents.run( + children=children, + style_id=style_id, + style_name=style_name, + is_bold=is_bold, + is_italic=is_italic, + is_underline=is_underline, + is_strikethrough=is_strikethrough, + vertical_alignment=vertical_alignment, + )) + + + @handler("w:p") + def paragraph(element): + properties = element.find_child_or_null("w:pPr") + style_id = properties \ + .find_child_or_null("w:pStyle") \ + .attributes.get("w:val") + + if style_id is None: + style_name = None + else: + style_name = styles.find_paragraph_style_by_id(style_id).name + + numbering_properties = properties.find_child("w:numPr") + if numbering_properties is None: + numbering = None + else: + numbering = _read_numbering_properties(numbering_properties) + + return _read_xml_elements(element.children) \ + .map(lambda children: documents.paragraph( + children=children, + style_id=style_id, + style_name=style_name, + numbering=numbering, + )) \ + .append_extra() + + def _read_numbering_properties(element): + num_id = element.find_child("w:numId").attributes["w:val"] + level_index = element.find_child("w:ilvl").attributes["w:val"] + return numbering.find_level(num_id, level_index) + + + @handler("w:tab") + def tab(element): + return _success(documents.tab()) + + + @handler("w:tbl") + def table(element): + return _read_xml_elements(element.children) \ + .map(documents.table) + + + @handler("w:tr") + def table_row(element): + return _read_xml_elements(element.children) \ + .map(documents.table_row) + + + @handler("w:tc") + def table_cell(element): + return _read_xml_elements(element.children) \ + .map(documents.table_cell) + + + @handler("w:ins") + @handler("w:smartTag") + @handler("w:drawing") + @handler("v:shape") + @handler("v:textbox") + @handler("w:txbxContent") + def read_child_elements(element): + return _read_xml_elements(element.children) + + + @handler("w:pict") + def pict(element): + return read_child_elements(element).to_extra() + + + @handler("w:hyperlink") + def hyperlink(element): + relationship_id = element.attributes.get("r:id") + anchor = element.attributes.get("w:anchor") + children_result = _read_xml_elements(element.children) + if relationship_id is not None: + href = relationships[relationship_id].target + return children_result.map(lambda children: documents.hyperlink(href=href, children=children)) + elif anchor is not None: + return children_result.map(lambda children: documents.hyperlink(anchor=anchor, children=children)) + else: + return children_result + + @handler("w:bookmarkStart") + def bookmark_start(element): + name = element.attributes.get("w:name") + if name == "_GoBack": + return _empty_result + else: + return _success(documents.bookmark(name)) + + + @handler("w:br") + def br(element): + break_type = element.attributes.get("w:type") + if break_type: + warning = results.warning("Unsupported break type: {0}".format(break_type)) + return _empty_result_with_messages([warning]) + else: + return _success(documents.line_break()) + + @handler("wp:inline") + @handler("wp:anchor") + def inline(element): + alt_text = element.find_child_or_null("wp:docPr").attributes.get("descr") + blips = element.find_children("a:graphic") \ + .find_children("a:graphicData") \ + .find_children("pic:pic") \ + .find_children("pic:blipFill") \ + .find_children("a:blip") + return _read_blips(blips, alt_text) + + def _read_blips(blips, alt_text): + return _combine_results(map(lambda blip: _read_blip(blip, alt_text), blips)) + + def _read_blip(element, alt_text): + relationship_id = element.attributes["r:embed"] + image_path = "word/" + relationships[relationship_id].target.lstrip("/") + content_type = content_types.find_content_type(image_path) + + def open_image(): + image_file = docx_file.open(image_path) + if hasattr(image_file, "__exit__"): + return image_file + else: + return contextlib.closing(image_file) + + image = documents.image(alt_text=alt_text, content_type=content_type, open=open_image) + + if content_type in ["image/png", "image/gif", "image/jpeg", "image/svg+xml", "image/tiff"]: + messages = [] + else: + messages = [results.warning("Image of type {0} is unlikely to display in web browsers".format(content_type))] + + return _element_result_with_messages(image, messages) + + def note_reference_reader(note_type): + @handler("w:{0}Reference".format(note_type)) + def note_reference(element): + return _success(documents.note_reference(note_type, element.attributes["w:id"])) + + return note_reference + + note_reference_reader("footnote") + note_reference_reader("endnote") + + @handler("mc:AlternateContent") + def alternate_content(element): + return read_child_elements(element.find_child("mc:Fallback")) + + def read(element): + handler = _handlers.get(element.name) + if handler is None: + if element.name not in _ignored_elements: + warning = results.warning("An unrecognised element was ignored: {0}".format(element.name)) + return _empty_result_with_messages([warning]) + else: + return _success(None) + else: + return handler(element) + + + def _read_xml_elements(elements): + return _combine_results(map(read, elements)) \ + .map(lambda values: lists.collect(values)) + + return read, _read_xml_elements + + +def _find(predicate, iterable): + for item in iterable: + if predicate(item): + return item + + +def _find_child(element, name): + return _find(lambda child: child.name == name, element.children) + + +def _inner_text(node): + if node.node_type == node_types.text: + return node.value + else: + return "".join(_inner_text(child) for child in node.children) + + + +class _ReadResult(object): + def __init__(self, value, extra, messages): + if extra is None: + extra = [] + self._result = results.Result((value, extra), messages) + + @property + def value(self): + return self._result.value[0] + + @property + def extra(self): + return self._result.value[1] + + @property + def messages(self): + return self._result.messages + + def map(self, func): + result = self._result.map(lambda value: func(value[0])) + return _ReadResult(result.value, self.extra, result.messages) + + def to_extra(self): + return _ReadResult(None, _concat(self.extra, self.value), self.messages) + + def append_extra(self): + return _ReadResult(_concat(self.value, self.extra), None, self.messages) + +def _success(element): + return _ReadResult(element, None, []) + +def _element_result_with_messages(element, messages): + return _ReadResult(element, None, messages) + +def _combine_results(read_results): + combined = results.combine(result._result for result in read_results) + if combined.value: + value, extras = map(list, zip(*combined.value)) + extra = sum(extras, []) + else: + value, extra = [], None + return _ReadResult(value, extra, combined.messages) + +_empty_result = _success(None) + +def _empty_result_with_messages(messages): + return _ReadResult(None, None, messages) + +def _concat(*values): + valid_values = list(filter(None, values)) + if not valid_values: + return None + elif len(valid_values) == 1: + return valid_values[0] + else: + return sum(list(map(_to_list, valid_values)), []) + +def _to_list(value): + if isinstance(value, list): + return value + else: + return [value] diff --git a/mammoth/docx/document_xml.py b/mammoth/docx/document_xml.py index 3147ed4..7288dc2 100644 --- a/mammoth/docx/document_xml.py +++ b/mammoth/docx/document_xml.py @@ -1,9 +1,6 @@ -import contextlib - from .. import documents from .. import results -from .. import lists -from .xmlparser import node_types +from . import body_xml def read_document_xml_element(element, @@ -17,349 +14,19 @@ def read_document_xml_element(element, note_elements = (footnote_elements or []) + (endnote_elements or []) - reader = _create_reader( + body_reader = body_xml.reader( numbering=numbering, content_types=content_types, relationships=relationships, styles=styles, - note_elements=note_elements, docx_file=docx_file, ) - result = reader(element) - return results.Result(result.value, result.messages) - -def _create_reader(numbering, content_types, relationships, styles, note_elements, docx_file): - _handlers = {} - _ignored_elements = set([ - "w:bookmarkStart", - "w:bookmarkEnd", - "w:sectPr", - "w:proofErr", - "w:lastRenderedPageBreak", - "w:commentRangeStart", - "w:commentRangeEnd", - "w:commentReference", - "w:del", - "w:footnoteRef", - "w:endnoteRef", - "w:pPr", - "w:rPr", - "w:tblPr", - "w:tblGrid", - "w:tcPr", - ]) - - def handler(name): - def add(func): - _handlers[name] = func - return func - - return add - - @handler("w:t") - def text(element): - return _success(documents.Text(_inner_text(element))) - - - @handler("w:r") - def run(element): - properties = element.find_child_or_null("w:rPr") - style_id = properties \ - .find_child_or_null("w:rStyle") \ - .attributes.get("w:val") - - if style_id is None: - style_name = None - else: - style_name = styles.find_character_style_by_id(style_id).name - - vertical_alignment = properties \ - .find_child_or_null("w:vertAlign") \ - .attributes.get("w:val") - - is_bold = properties.find_child("w:b") - is_italic = properties.find_child("w:i") - is_underline = properties.find_child("w:u") - is_strikethrough = properties.find_child("w:strike") - - return _read_xml_elements(element.children) \ - .map(lambda children: documents.run( - children=children, - style_id=style_id, - style_name=style_name, - is_bold=is_bold, - is_italic=is_italic, - is_underline=is_underline, - is_strikethrough=is_strikethrough, - vertical_alignment=vertical_alignment, - )) - - - @handler("w:p") - def paragraph(element): - properties = element.find_child_or_null("w:pPr") - style_id = properties \ - .find_child_or_null("w:pStyle") \ - .attributes.get("w:val") - - if style_id is None: - style_name = None - else: - style_name = styles.find_paragraph_style_by_id(style_id).name - - numbering_properties = properties.find_child("w:numPr") - if numbering_properties is None: - numbering = None - else: - numbering = _read_numbering_properties(numbering_properties) - - return _read_xml_elements(element.children) \ - .map(lambda children: documents.paragraph( - children=children, - style_id=style_id, - style_name=style_name, - numbering=numbering, - )) \ - .append_extra() - - def _read_numbering_properties(element): - num_id = element.find_child("w:numId").attributes["w:val"] - level_index = element.find_child("w:ilvl").attributes["w:val"] - return numbering.find_level(num_id, level_index) - - - @handler("w:body") - def body(element): - return _read_xml_elements(element.children) - - - @handler("w:document") - def document(element): - body_element = _find_child(element, "w:body") - children_result = _read_xml_elements(body_element.children) - notes_result = _combine_results(map(_read_note, note_elements)).map(documents.notes) - return results.map(documents.document, children_result, notes_result) - def _read_note(element): - return _read_xml_elements(element.body).map( + return body_reader.read_all(element.body).map( lambda body: documents.note(element.note_type, element.id, body)) - - - @handler("w:tab") - def tab(element): - return _success(documents.tab()) - - - @handler("w:tbl") - def table(element): - return _read_xml_elements(element.children) \ - .map(documents.table) - - - @handler("w:tr") - def table_row(element): - return _read_xml_elements(element.children) \ - .map(documents.table_row) - - - @handler("w:tc") - def table_cell(element): - return _read_xml_elements(element.children) \ - .map(documents.table_cell) - - - @handler("w:ins") - @handler("w:smartTag") - @handler("w:drawing") - @handler("v:shape") - @handler("v:textbox") - @handler("w:txbxContent") - def read_child_elements(element): - return _read_xml_elements(element.children) - - - @handler("w:pict") - def pict(element): - return read_child_elements(element).to_extra() - - - @handler("w:hyperlink") - def hyperlink(element): - relationship_id = element.attributes.get("r:id") - anchor = element.attributes.get("w:anchor") - children_result = _read_xml_elements(element.children) - if relationship_id is not None: - href = relationships[relationship_id].target - return children_result.map(lambda children: documents.hyperlink(href=href, children=children)) - elif anchor is not None: - return children_result.map(lambda children: documents.hyperlink(anchor=anchor, children=children)) - else: - return children_result - - @handler("w:bookmarkStart") - def bookmark_start(element): - name = element.attributes.get("w:name") - if name == "_GoBack": - return _empty_result - else: - return _success(documents.bookmark(name)) - - - @handler("w:br") - def br(element): - break_type = element.attributes.get("w:type") - if break_type: - warning = results.warning("Unsupported break type: {0}".format(break_type)) - return _empty_result_with_messages([warning]) - else: - return _success(documents.line_break()) - - @handler("wp:inline") - @handler("wp:anchor") - def inline(element): - alt_text = element.find_child_or_null("wp:docPr").attributes.get("descr") - blips = element.find_children("a:graphic") \ - .find_children("a:graphicData") \ - .find_children("pic:pic") \ - .find_children("pic:blipFill") \ - .find_children("a:blip") - return _read_blips(blips, alt_text) - - def _read_blips(blips, alt_text): - return _combine_results(map(lambda blip: _read_blip(blip, alt_text), blips)) - - def _read_blip(element, alt_text): - relationship_id = element.attributes["r:embed"] - image_path = "word/" + relationships[relationship_id].target.lstrip("/") - content_type = content_types.find_content_type(image_path) - - def open_image(): - image_file = docx_file.open(image_path) - if hasattr(image_file, "__exit__"): - return image_file - else: - return contextlib.closing(image_file) - - image = documents.image(alt_text=alt_text, content_type=content_type, open=open_image) - - if content_type in ["image/png", "image/gif", "image/jpeg", "image/svg+xml", "image/tiff"]: - messages = [] - else: - messages = [results.warning("Image of type {0} is unlikely to display in web browsers".format(content_type))] - - return _element_result_with_messages(image, messages) - - def note_reference_reader(note_type): - @handler("w:{0}Reference".format(note_type)) - def note_reference(element): - return _success(documents.note_reference(note_type, element.attributes["w:id"])) - - return note_reference - - note_reference_reader("footnote") - note_reference_reader("endnote") - - @handler("mc:AlternateContent") - def alternate_content(element): - return read_child_elements(element.find_child("mc:Fallback")) - - def read(element): - handler = _handlers.get(element.name) - if handler is None: - if element.name not in _ignored_elements: - warning = results.warning("An unrecognised element was ignored: {0}".format(element.name)) - return _empty_result_with_messages([warning]) - else: - return _success(None) - else: - return handler(element) - - - def _read_xml_elements(elements): - return _combine_results(map(read, elements)) \ - .map(lambda values: lists.collect(values)) - - return read - - -def _find(predicate, iterable): - for item in iterable: - if predicate(item): - return item - - -def _find_child(element, name): - return _find(lambda child: child.name == name, element.children) - - -def _inner_text(node): - if node.node_type == node_types.text: - return node.value - else: - return "".join(_inner_text(child) for child in node.children) - - - -class _ReadResult(object): - def __init__(self, value, extra, messages): - if extra is None: - extra = [] - self._result = results.Result((value, extra), messages) - - @property - def value(self): - return self._result.value[0] - - @property - def extra(self): - return self._result.value[1] - - @property - def messages(self): - return self._result.messages - - def map(self, func): - result = self._result.map(lambda value: func(value[0])) - return _ReadResult(result.value, self.extra, result.messages) - - def to_extra(self): - return _ReadResult(None, _concat(self.extra, self.value), self.messages) - - def append_extra(self): - return _ReadResult(_concat(self.value, self.extra), None, self.messages) - -def _success(element): - return _ReadResult(element, None, []) - -def _element_result_with_messages(element, messages): - return _ReadResult(element, None, messages) - -def _combine_results(read_results): - combined = results.combine(result._result for result in read_results) - if combined.value: - value, extras = map(list, zip(*combined.value)) - extra = sum(extras, []) - else: - value, extra = [], None - return _ReadResult(value, extra, combined.messages) - -_empty_result = _success(None) - -def _empty_result_with_messages(messages): - return _ReadResult(None, None, messages) - -def _concat(*values): - valid_values = list(filter(None, values)) - if not valid_values: - return None - elif len(valid_values) == 1: - return valid_values[0] - else: - return sum(list(map(_to_list, valid_values)), []) -def _to_list(value): - if isinstance(value, list): - return value - else: - return [value] + body_element = element.find_child("w:body") + children_result = body_reader.read_all(body_element.children) + notes_result = results.combine(map(_read_note, note_elements)).map(documents.notes) + return results.map(documents.document, children_result, notes_result) diff --git a/tests/docx/body_xml_tests.py b/tests/docx/body_xml_tests.py new file mode 100644 index 0000000..1f7e10c --- /dev/null +++ b/tests/docx/body_xml_tests.py @@ -0,0 +1,494 @@ +import io + +from nose.tools import istest, assert_equal +import funk + +from mammoth import documents, results +from mammoth.docx.xmlparser import element as xml_element, text as xml_text +from mammoth.docx import body_xml +from mammoth.docx.numbering_xml import Numbering +from mammoth.docx.relationships_xml import Relationships, Relationship +from mammoth.docx.styles_xml import Styles, Style + + +@istest +class ReadXmlElementTests(object): + @istest + def text_from_text_element_is_read(self): + element = _text_element("Hello!") + assert_equal(documents.Text("Hello!"), _read_and_get_document_xml_element(element)) + + @istest + def can_read_text_within_run(self): + element = _run_element_with_text("Hello!") + assert_equal( + documents.run([documents.Text("Hello!")]), + _read_and_get_document_xml_element(element) + ) + + @istest + def can_read_text_within_paragraph(self): + element = _paragraph_element_with_text("Hello!") + assert_equal( + documents.paragraph([documents.run([documents.Text("Hello!")])]), + _read_and_get_document_xml_element(element) + ) + + @istest + def paragraph_has_no_style_if_it_has_no_properties(self): + element = xml_element("w:p") + assert_equal(None, _read_and_get_document_xml_element(element).style_id) + + @istest + def paragraph_has_style_id_read_from_paragraph_properties_if_present(self): + style_xml = xml_element("w:pStyle", {"w:val": "Heading1"}) + properties_xml = xml_element("w:pPr", {}, [style_xml]) + paragraph_xml = xml_element("w:p", {}, [properties_xml]) + + styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {}) + + paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles) + assert_equal("Heading1", paragraph.style_id) + + @istest + def paragraph_has_style_name_read_from_paragraph_properties_and_styles(self): + style_xml = xml_element("w:pStyle", {"w:val": "Heading1"}) + properties_xml = xml_element("w:pPr", {}, [style_xml]) + paragraph_xml = xml_element("w:p", {}, [properties_xml]) + + styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {}) + + paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles) + assert_equal("Heading 1", paragraph.style_name) + + @istest + def paragraph_has_no_numbering_if_it_has_no_numbering_properties(self): + element = xml_element("w:p") + assert_equal(None, _read_and_get_document_xml_element(element).numbering) + + @istest + def paragraph_has_numbering_properties_from_paragraph_properties_if_present(self): + numbering_properties_xml = xml_element("w:numPr", {}, [ + xml_element("w:ilvl", {"w:val": "1"}), + xml_element("w:numId", {"w:val": "42"}), + ]) + properties_xml = xml_element("w:pPr", {}, [numbering_properties_xml]) + paragraph_xml = xml_element("w:p", {}, [properties_xml]) + + numbering = Numbering({"42": {"1": documents.numbering_level("1", True)}}) + paragraph = _read_and_get_document_xml_element(paragraph_xml, numbering=numbering) + + assert_equal("1", paragraph.numbering.level_index) + assert_equal(True, paragraph.numbering.is_ordered) + + @istest + def run_has_no_style_if_it_has_no_properties(self): + element = xml_element("w:r") + assert_equal(None, _read_and_get_document_xml_element(element).style_id) + + @istest + def run_has_style_id_read_from_run_properties_if_present(self): + style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"}) + + styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")}) + + run = self._read_run_with_properties([style_xml], styles=styles) + assert_equal("Heading1Char", run.style_id) + + @istest + def run_has_style_name_read_from_run_properties_and_styles(self): + style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"}) + + styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")}) + + run = self._read_run_with_properties([style_xml], styles=styles) + assert_equal("Heading 1 Char", run.style_name) + + @istest + def run_is_not_bold_if_bold_element_is_not_present(self): + run = self._read_run_with_properties([]) + assert_equal(False, run.is_bold) + + @istest + def run_is_bold_if_bold_element_is_present(self): + run = self._read_run_with_properties([xml_element("w:b")]) + assert_equal(True, run.is_bold) + + @istest + def run_is_not_italic_if_italic_element_is_not_present(self): + run = self._read_run_with_properties([]) + assert_equal(False, run.is_italic) + + @istest + def run_is_italic_if_italic_element_is_present(self): + run = self._read_run_with_properties([xml_element("w:i")]) + assert_equal(True, run.is_italic) + + @istest + def run_is_not_underlined_if_underline_element_is_not_present(self): + run = self._read_run_with_properties([]) + assert_equal(False, run.is_underline) + + @istest + def run_is_underlined_if_underline_element_is_present(self): + run = self._read_run_with_properties([xml_element("w:u")]) + assert_equal(True, run.is_underline) + + @istest + def run_is_not_struckthrough_if_strikethrough_element_is_not_present(self): + run = self._read_run_with_properties([]) + assert_equal(False, run.is_strikethrough) + + @istest + def run_is_struckthrough_if_strikethrough_element_is_present(self): + run = self._read_run_with_properties([xml_element("w:strike")]) + assert_equal(True, run.is_strikethrough) + + @istest + def run_has_baseline_vertical_alignment_if_vertical_alignment_element_is_not_present(self): + run = self._read_run_with_properties([]) + assert_equal(documents.VerticalAlignment.baseline, run.vertical_alignment) + + @istest + def run_has_vertical_alignment_read_from_vertical_alignment_element(self): + run = self._read_run_with_properties([xml_element("w:vertAlign", {"w:val": "superscript"})]) + assert_equal(documents.VerticalAlignment.superscript, run.vertical_alignment) + + def _read_run_with_properties(self, properties, styles=None): + properties_xml = xml_element("w:rPr", {}, properties) + run_xml = xml_element("w:r", {}, [properties_xml]) + return _read_and_get_document_xml_element(run_xml, styles=styles) + + + @istest + def can_read_tab_element(self): + element = xml_element("w:tab") + tab = _read_and_get_document_xml_element(element) + assert_equal(documents.tab(), tab) + + + @istest + def word_table_is_read_as_document_table_element(self): + element = xml_element("w:tbl", {}, [ + xml_element("w:tr", {}, [ + xml_element("w:tc", {}, [ + xml_element("w:p", {}, []) + ]), + ]), + ]) + table = _read_and_get_document_xml_element(element) + expected_result = documents.table([ + documents.table_row([ + documents.table_cell([ + documents.paragraph([]) + ]) + ]) + ]) + assert_equal(expected_result, table) + + + @istest + def children_of_w_ins_are_converted_normally(self): + element = xml_element("w:p", {}, [ + xml_element("w:ins", {}, [ + xml_element("w:r") + ]) + ]) + assert_equal( + documents.paragraph([documents.run([])]), + _read_and_get_document_xml_element(element) + ) + + @istest + def children_of_w_smart_tag_are_converted_normally(self): + element = xml_element("w:p", {}, [ + xml_element("w:smartTag", {}, [ + xml_element("w:r") + ]) + ]) + assert_equal( + documents.paragraph([documents.run([])]), + _read_and_get_document_xml_element(element) + ) + + @istest + def hyperlink_is_read_if_it_has_a_relationship_id(self): + relationships = Relationships({ + "r42": Relationship(target="http://example.com") + }) + run_element = xml_element("w:r") + element = xml_element("w:hyperlink", {"r:id": "r42"}, [run_element]) + assert_equal( + documents.hyperlink(href="http://example.com", children=[documents.run([])]), + _read_and_get_document_xml_element(element, relationships=relationships) + ) + + @istest + def hyperlink_is_read_if_it_has_an_anchor_attribute(self): + run_element = xml_element("w:r") + element = xml_element("w:hyperlink", {"w:anchor": "start"}, [run_element]) + assert_equal( + documents.hyperlink(anchor="start", children=[documents.run([])]), + _read_and_get_document_xml_element(element) + ) + + @istest + def hyperlink_is_ignored_if_it_does_not_have_a_relationship_id_nor_anchor(self): + run_element = xml_element("w:r") + element = xml_element("w:hyperlink", {}, [run_element]) + assert_equal( + [documents.run([])], + _read_and_get_document_xml_element(element) + ) + + @istest + def go_back_bookmark_is_ignored(self): + element = xml_element("w:bookmarkStart", {"w:name": "_GoBack"}) + assert_equal(None, _read_and_get_document_xml_element(element)) + + @istest + def bookmark_start_is_read_if_name_is_not_go_back(self): + element = xml_element("w:bookmarkStart", {"w:name": "start"}) + assert_equal( + documents.bookmark("start"), + _read_and_get_document_xml_element(element) + ) + + @istest + def br_is_read_as_line_break(self): + break_element = xml_element("w:br", {}, []) + result = _read_and_get_document_xml_element(break_element) + assert_equal(result, documents.line_break()) + + + @istest + def warning_on_breaks_that_arent_line_breaks(self): + break_element = xml_element("w:br", {"w:type": "page"}, []) + result = _read_document_xml_element(break_element) + expected_warning = results.warning("Unsupported break type: page") + assert_equal([expected_warning], result.messages) + assert_equal(None, result.value) + + + @istest + @funk.with_context + def can_read_inline_pictures(self, context): + drawing_element = _create_inline_image( + relationship_id="rId5", + description="It's a hat", + ) + + image_bytes = b"Not an image at all!" + + relationships = Relationships({ + "rId5": Relationship(target="media/hat.png") + }) + + docx_file = context.mock() + funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes)) + + content_types = context.mock() + funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png") + + image = _read_and_get_document_xml_element( + drawing_element, + content_types=content_types, + relationships=relationships, + docx_file=docx_file, + )[0] + assert_equal(documents.Image, type(image)) + assert_equal("It's a hat", image.alt_text) + assert_equal("image/png", image.content_type) + with image.open() as image_file: + assert_equal(image_bytes, image_file.read()) + + @istest + @funk.with_context + def can_read_anchored_pictures(self, context): + drawing_element = _create_anchored_image( + relationship_id="rId5", + description="It's a hat", + ) + + image_bytes = b"Not an image at all!" + + relationships = Relationships({ + "rId5": Relationship(target="media/hat.png") + }) + + docx_file = context.mock() + funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes)) + + content_types = context.mock() + funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png") + + image = _read_and_get_document_xml_element( + drawing_element, + content_types=content_types, + relationships=relationships, + docx_file=docx_file, + )[0] + assert_equal(documents.Image, type(image)) + assert_equal("It's a hat", image.alt_text) + assert_equal("image/png", image.content_type) + with image.open() as image_file: + assert_equal(image_bytes, image_file.read()) + + + @istest + @funk.with_context + def warning_if_unsupported_image_type(self, context): + drawing_element = _create_inline_image( + relationship_id="rId5", + description="It's a hat", + ) + + image_bytes = b"Not an image at all!" + + relationships = Relationships({ + "rId5": Relationship(target="media/hat.emf") + }) + + docx_file = context.mock() + funk.allows(docx_file).open("word/media/hat.emf").returns(io.BytesIO(image_bytes)) + + content_types = context.mock() + funk.allows(content_types).find_content_type("word/media/hat.emf").returns("image/x-emf") + + result = _read_document_xml_element( + drawing_element, + content_types=content_types, + relationships=relationships, + docx_file=docx_file, + ) + assert_equal("image/x-emf", result.value[0].content_type) + expected_warning = results.warning("Image of type image/x-emf is unlikely to display in web browsers") + assert_equal([expected_warning], result.messages) + + @istest + def footnote_reference_has_id_read(self): + footnote_xml = xml_element("w:footnoteReference", {"w:id": "4"}) + footnote = _read_and_get_document_xml_element(footnote_xml) + assert_equal("4", footnote.note_id) + + @istest + def ignored_elements_are_ignored_without_message(self): + element = xml_element("w:bookmarkEnd") + result = _read_document_xml_element(element) + assert_equal(None, result.value) + assert_equal([], result.messages) + + @istest + def unrecognised_elements_emit_warning(self): + element = xml_element("w:huh", {}, []) + result = _read_document_xml_element(element) + expected_warning = results.warning("An unrecognised element was ignored: w:huh") + assert_equal([expected_warning], result.messages) + + @istest + def unrecognised_elements_are_ignored(self): + element = xml_element("w:huh", {}, []) + assert_equal(None, _read_document_xml_element(element).value) + + @istest + def unrecognised_children_are_ignored(self): + element = xml_element("w:r", {}, [_text_element("Hello!"), xml_element("w:huh", {}, [])]) + assert_equal( + documents.run([documents.Text("Hello!")]), + _read_document_xml_element(element).value + ) + + @istest + def text_boxes_have_content_appended_after_containing_paragraph(self): + text_box = xml_element("w:pict", {}, [ + xml_element("v:shape", {}, [ + xml_element("v:textbox", {}, [ + xml_element("w:txbxContent", {}, [ + _paragraph_with_style_id("textbox-content") + ]) + ]) + ]) + ]) + paragraph = xml_element("w:p", {}, [ + xml_element("w:r", {}, [text_box]) + ]) + result = _read_and_get_document_xml_element(paragraph) + assert_equal(result[1].style_id, "textbox-content") + + @istest + def alternate_content_is_read_using_fallback(self): + element = xml_element("mc:AlternateContent", {}, [ + xml_element("mc:Choice", {"Requires": "wps"}, [ + _paragraph_with_style_id("first") + ]), + xml_element("mc:Fallback", {}, [ + _paragraph_with_style_id("second") + ]) + ]) + result = _read_and_get_document_xml_element(element) + assert_equal("second", result[0].style_id) + + +def _read_and_get_document_xml_element(*args, **kwargs): + styles = kwargs.pop("styles", FakeStyles()) + result = _read_document_xml_element(*args, styles=styles, **kwargs) + assert_equal([], result.messages) + return result.value + + +def _read_document_xml_element(element, *args, **kwargs): + reader = body_xml.reader(*args, **kwargs) + return reader.read(element) + + +class FakeStyles(object): + def find_paragraph_style_by_id(self, style_id): + return Style(style_id, style_id) + +def _document_element_with_text(text): + return xml_element("w:document", {}, [ + xml_element("w:body", {}, [_paragraph_element_with_text(text)]) + ]) + + +def _paragraph_element_with_text(text): + return xml_element("w:p", {}, [_run_element_with_text(text)]) + +def _paragraph_with_style_id(style_id): + style_xml = xml_element("w:pStyle", {"w:val": style_id}) + properties_xml = xml_element("w:pPr", {}, [style_xml]) + return xml_element("w:p", {}, [properties_xml]) + +def _run_element_with_text(text): + return xml_element("w:r", {}, [_text_element(text)]) + + +def _text_element(value): + return xml_element("w:t", {}, [xml_text(value)]) + + +def _create_inline_image(description, relationship_id): + return xml_element("w:drawing", {}, [ + xml_element("wp:inline", {}, _create_image_elements(description, relationship_id)) + ]) + + +def _create_anchored_image(description, relationship_id): + return xml_element("w:drawing", {}, [ + xml_element("wp:anchor", {}, _create_image_elements(description, relationship_id)) + ]) + + +def _create_image_elements(description, relationship_id): + return [ + xml_element("wp:docPr", {"descr": description}), + xml_element("a:graphic", {}, [ + xml_element("a:graphicData", {}, [ + xml_element("pic:pic", {}, [ + xml_element("pic:blipFill", {}, [ + xml_element("a:blip", {"r:embed": relationship_id}) + ]) + ]) + ]) + ]) + ] diff --git a/tests/docx/document_xml_tests.py b/tests/docx/document_xml_tests.py index bc6fcfb..00c7770 100644 --- a/tests/docx/document_xml_tests.py +++ b/tests/docx/document_xml_tests.py @@ -1,40 +1,13 @@ -import io - from nose.tools import istest, assert_equal -import funk -from mammoth import documents, results +from mammoth import documents from mammoth.docx.xmlparser import element as xml_element, text as xml_text from mammoth.docx.document_xml import read_document_xml_element -from mammoth.docx.numbering_xml import Numbering -from mammoth.docx.relationships_xml import Relationships, Relationship -from mammoth.docx.styles_xml import Styles, Style from mammoth.docx.notes_xml import NoteElement @istest class ReadXmlElementTests(object): - @istest - def text_from_text_element_is_read(self): - element = _text_element("Hello!") - assert_equal(documents.Text("Hello!"), _read_and_get_document_xml_element(element)) - - @istest - def can_read_text_within_run(self): - element = _run_element_with_text("Hello!") - assert_equal( - documents.run([documents.Text("Hello!")]), - _read_and_get_document_xml_element(element) - ) - - @istest - def can_read_text_within_paragraph(self): - element = _paragraph_element_with_text("Hello!") - assert_equal( - documents.paragraph([documents.run([documents.Text("Hello!")])]), - _read_and_get_document_xml_element(element) - ) - @istest def can_read_text_within_document(self): element = _document_element_with_text("Hello!") @@ -43,337 +16,6 @@ class ReadXmlElementTests(object): _read_and_get_document_xml_element(element) ) - @istest - def paragraph_has_no_style_if_it_has_no_properties(self): - element = xml_element("w:p") - assert_equal(None, _read_and_get_document_xml_element(element).style_id) - - @istest - def paragraph_has_style_id_read_from_paragraph_properties_if_present(self): - style_xml = xml_element("w:pStyle", {"w:val": "Heading1"}) - properties_xml = xml_element("w:pPr", {}, [style_xml]) - paragraph_xml = xml_element("w:p", {}, [properties_xml]) - - styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {}) - - paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles) - assert_equal("Heading1", paragraph.style_id) - - @istest - def paragraph_has_style_name_read_from_paragraph_properties_and_styles(self): - style_xml = xml_element("w:pStyle", {"w:val": "Heading1"}) - properties_xml = xml_element("w:pPr", {}, [style_xml]) - paragraph_xml = xml_element("w:p", {}, [properties_xml]) - - styles = Styles({"Heading1": Style(style_id="Heading1", name="Heading 1")}, {}) - - paragraph = _read_and_get_document_xml_element(paragraph_xml, styles=styles) - assert_equal("Heading 1", paragraph.style_name) - - @istest - def paragraph_has_no_numbering_if_it_has_no_numbering_properties(self): - element = xml_element("w:p") - assert_equal(None, _read_and_get_document_xml_element(element).numbering) - - @istest - def paragraph_has_numbering_properties_from_paragraph_properties_if_present(self): - numbering_properties_xml = xml_element("w:numPr", {}, [ - xml_element("w:ilvl", {"w:val": "1"}), - xml_element("w:numId", {"w:val": "42"}), - ]) - properties_xml = xml_element("w:pPr", {}, [numbering_properties_xml]) - paragraph_xml = xml_element("w:p", {}, [properties_xml]) - - numbering = Numbering({"42": {"1": documents.numbering_level("1", True)}}) - paragraph = _read_and_get_document_xml_element(paragraph_xml, numbering=numbering) - - assert_equal("1", paragraph.numbering.level_index) - assert_equal(True, paragraph.numbering.is_ordered) - - @istest - def run_has_no_style_if_it_has_no_properties(self): - element = xml_element("w:r") - assert_equal(None, _read_and_get_document_xml_element(element).style_id) - - @istest - def run_has_style_id_read_from_run_properties_if_present(self): - style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"}) - - styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")}) - - run = self._read_run_with_properties([style_xml], styles=styles) - assert_equal("Heading1Char", run.style_id) - - @istest - def run_has_style_name_read_from_run_properties_and_styles(self): - style_xml = xml_element("w:rStyle", {"w:val": "Heading1Char"}) - - styles = Styles({}, {"Heading1Char": Style(style_id="Heading1Char", name="Heading 1 Char")}) - - run = self._read_run_with_properties([style_xml], styles=styles) - assert_equal("Heading 1 Char", run.style_name) - - @istest - def run_is_not_bold_if_bold_element_is_not_present(self): - run = self._read_run_with_properties([]) - assert_equal(False, run.is_bold) - - @istest - def run_is_bold_if_bold_element_is_present(self): - run = self._read_run_with_properties([xml_element("w:b")]) - assert_equal(True, run.is_bold) - - @istest - def run_is_not_italic_if_italic_element_is_not_present(self): - run = self._read_run_with_properties([]) - assert_equal(False, run.is_italic) - - @istest - def run_is_italic_if_italic_element_is_present(self): - run = self._read_run_with_properties([xml_element("w:i")]) - assert_equal(True, run.is_italic) - - @istest - def run_is_not_underlined_if_underline_element_is_not_present(self): - run = self._read_run_with_properties([]) - assert_equal(False, run.is_underline) - - @istest - def run_is_underlined_if_underline_element_is_present(self): - run = self._read_run_with_properties([xml_element("w:u")]) - assert_equal(True, run.is_underline) - - @istest - def run_is_not_struckthrough_if_strikethrough_element_is_not_present(self): - run = self._read_run_with_properties([]) - assert_equal(False, run.is_strikethrough) - - @istest - def run_is_struckthrough_if_strikethrough_element_is_present(self): - run = self._read_run_with_properties([xml_element("w:strike")]) - assert_equal(True, run.is_strikethrough) - - @istest - def run_has_baseline_vertical_alignment_if_vertical_alignment_element_is_not_present(self): - run = self._read_run_with_properties([]) - assert_equal(documents.VerticalAlignment.baseline, run.vertical_alignment) - - @istest - def run_has_vertical_alignment_read_from_vertical_alignment_element(self): - run = self._read_run_with_properties([xml_element("w:vertAlign", {"w:val": "superscript"})]) - assert_equal(documents.VerticalAlignment.superscript, run.vertical_alignment) - - def _read_run_with_properties(self, properties, styles=None): - properties_xml = xml_element("w:rPr", {}, properties) - run_xml = xml_element("w:r", {}, [properties_xml]) - return _read_and_get_document_xml_element(run_xml, styles=styles) - - - @istest - def can_read_tab_element(self): - element = xml_element("w:tab") - tab = _read_and_get_document_xml_element(element) - assert_equal(documents.tab(), tab) - - - @istest - def word_table_is_read_as_document_table_element(self): - element = xml_element("w:tbl", {}, [ - xml_element("w:tr", {}, [ - xml_element("w:tc", {}, [ - xml_element("w:p", {}, []) - ]), - ]), - ]) - table = _read_and_get_document_xml_element(element) - expected_result = documents.table([ - documents.table_row([ - documents.table_cell([ - documents.paragraph([]) - ]) - ]) - ]) - assert_equal(expected_result, table) - - - @istest - def children_of_w_ins_are_converted_normally(self): - element = xml_element("w:p", {}, [ - xml_element("w:ins", {}, [ - xml_element("w:r") - ]) - ]) - assert_equal( - documents.paragraph([documents.run([])]), - _read_and_get_document_xml_element(element) - ) - - @istest - def children_of_w_smart_tag_are_converted_normally(self): - element = xml_element("w:p", {}, [ - xml_element("w:smartTag", {}, [ - xml_element("w:r") - ]) - ]) - assert_equal( - documents.paragraph([documents.run([])]), - _read_and_get_document_xml_element(element) - ) - - @istest - def hyperlink_is_read_if_it_has_a_relationship_id(self): - relationships = Relationships({ - "r42": Relationship(target="http://example.com") - }) - run_element = xml_element("w:r") - element = xml_element("w:hyperlink", {"r:id": "r42"}, [run_element]) - assert_equal( - documents.hyperlink(href="http://example.com", children=[documents.run([])]), - _read_and_get_document_xml_element(element, relationships=relationships) - ) - - @istest - def hyperlink_is_read_if_it_has_an_anchor_attribute(self): - run_element = xml_element("w:r") - element = xml_element("w:hyperlink", {"w:anchor": "start"}, [run_element]) - assert_equal( - documents.hyperlink(anchor="start", children=[documents.run([])]), - _read_and_get_document_xml_element(element) - ) - - @istest - def hyperlink_is_ignored_if_it_does_not_have_a_relationship_id_nor_anchor(self): - run_element = xml_element("w:r") - element = xml_element("w:hyperlink", {}, [run_element]) - assert_equal( - [documents.run([])], - _read_and_get_document_xml_element(element) - ) - - @istest - def go_back_bookmark_is_ignored(self): - element = xml_element("w:bookmarkStart", {"w:name": "_GoBack"}) - assert_equal(None, _read_and_get_document_xml_element(element)) - - @istest - def bookmark_start_is_read_if_name_is_not_go_back(self): - element = xml_element("w:bookmarkStart", {"w:name": "start"}) - assert_equal( - documents.bookmark("start"), - _read_and_get_document_xml_element(element) - ) - - @istest - def br_is_read_as_line_break(self): - break_element = xml_element("w:br", {}, []) - result = _read_and_get_document_xml_element(break_element) - assert_equal(result, documents.line_break()) - - - @istest - def warning_on_breaks_that_arent_line_breaks(self): - break_element = xml_element("w:br", {"w:type": "page"}, []) - result = read_document_xml_element(break_element) - expected_warning = results.warning("Unsupported break type: page") - assert_equal([expected_warning], result.messages) - assert_equal(None, result.value) - - - @istest - @funk.with_context - def can_read_inline_pictures(self, context): - drawing_element = _create_inline_image( - relationship_id="rId5", - description="It's a hat", - ) - - image_bytes = b"Not an image at all!" - - relationships = Relationships({ - "rId5": Relationship(target="media/hat.png") - }) - - docx_file = context.mock() - funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes)) - - content_types = context.mock() - funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png") - - image = _read_and_get_document_xml_element( - drawing_element, - content_types=content_types, - relationships=relationships, - docx_file=docx_file, - )[0] - assert_equal(documents.Image, type(image)) - assert_equal("It's a hat", image.alt_text) - assert_equal("image/png", image.content_type) - with image.open() as image_file: - assert_equal(image_bytes, image_file.read()) - - @istest - @funk.with_context - def can_read_anchored_pictures(self, context): - drawing_element = _create_anchored_image( - relationship_id="rId5", - description="It's a hat", - ) - - image_bytes = b"Not an image at all!" - - relationships = Relationships({ - "rId5": Relationship(target="media/hat.png") - }) - - docx_file = context.mock() - funk.allows(docx_file).open("word/media/hat.png").returns(io.BytesIO(image_bytes)) - - content_types = context.mock() - funk.allows(content_types).find_content_type("word/media/hat.png").returns("image/png") - - image = _read_and_get_document_xml_element( - drawing_element, - content_types=content_types, - relationships=relationships, - docx_file=docx_file, - )[0] - assert_equal(documents.Image, type(image)) - assert_equal("It's a hat", image.alt_text) - assert_equal("image/png", image.content_type) - with image.open() as image_file: - assert_equal(image_bytes, image_file.read()) - - - @istest - @funk.with_context - def warning_if_unsupported_image_type(self, context): - drawing_element = _create_inline_image( - relationship_id="rId5", - description="It's a hat", - ) - - image_bytes = b"Not an image at all!" - - relationships = Relationships({ - "rId5": Relationship(target="media/hat.emf") - }) - - docx_file = context.mock() - funk.allows(docx_file).open("word/media/hat.emf").returns(io.BytesIO(image_bytes)) - - content_types = context.mock() - funk.allows(content_types).find_content_type("word/media/hat.emf").returns("image/x-emf") - - result = read_document_xml_element( - drawing_element, - content_types=content_types, - relationships=relationships, - docx_file=docx_file, - ) - assert_equal("image/x-emf", result.value[0].content_type) - expected_warning = results.warning("Image of type image/x-emf is unlikely to display in web browsers") - assert_equal([expected_warning], result.messages) - @istest def footnotes_of_document_are_read(self): paragraph_xml = xml_element("w:p") @@ -387,125 +29,24 @@ class ReadXmlElementTests(object): assert_equal("4", footnote.note_id) assert isinstance(footnote.body[0], documents.Paragraph) - @istest - def footnote_reference_has_id_read(self): - footnote_xml = xml_element("w:footnoteReference", {"w:id": "4"}) - footnote = _read_and_get_document_xml_element(footnote_xml) - assert_equal("4", footnote.note_id) - - @istest - def ignored_elements_are_ignored_without_message(self): - element = xml_element("w:bookmarkEnd") - result = read_document_xml_element(element) - assert_equal(None, result.value) - assert_equal([], result.messages) - - @istest - def unrecognised_elements_emit_warning(self): - element = xml_element("w:huh", {}, []) - result = read_document_xml_element(element) - expected_warning = results.warning("An unrecognised element was ignored: w:huh") - assert_equal([expected_warning], result.messages) - - @istest - def unrecognised_elements_are_ignored(self): - element = xml_element("w:huh", {}, []) - assert_equal(None, read_document_xml_element(element).value) - - @istest - def unrecognised_children_are_ignored(self): - element = xml_element("w:r", {}, [_text_element("Hello!"), xml_element("w:huh", {}, [])]) - assert_equal( - documents.run([documents.Text("Hello!")]), - read_document_xml_element(element).value - ) - - @istest - def text_boxes_have_content_appended_after_containing_paragraph(self): - text_box = xml_element("w:pict", {}, [ - xml_element("v:shape", {}, [ - xml_element("v:textbox", {}, [ - xml_element("w:txbxContent", {}, [ - _paragraph_with_style_id("textbox-content") - ]) - ]) - ]) - ]) - paragraph = xml_element("w:p", {}, [ - xml_element("w:r", {}, [text_box]) - ]) - result = _read_and_get_document_xml_element(paragraph) - assert_equal(result[1].style_id, "textbox-content") - - @istest - def alternate_content_is_read_using_fallback(self): - element = xml_element("mc:AlternateContent", {}, [ - xml_element("mc:Choice", {"Requires": "wps"}, [ - _paragraph_with_style_id("first") - ]), - xml_element("mc:Fallback", {}, [ - _paragraph_with_style_id("second") - ]) - ]) - result = _read_and_get_document_xml_element(element) - assert_equal("second", result[0].style_id) - def _read_and_get_document_xml_element(*args, **kwargs): - styles = kwargs.pop("styles", FakeStyles()) - result = read_document_xml_element(*args, styles=styles, **kwargs) + result = read_document_xml_element(*args, **kwargs) assert_equal([], result.messages) return result.value -class FakeStyles(object): - def find_paragraph_style_by_id(self, style_id): - return Style(style_id, style_id) - def _document_element_with_text(text): return xml_element("w:document", {}, [ xml_element("w:body", {}, [_paragraph_element_with_text(text)]) ]) - def _paragraph_element_with_text(text): return xml_element("w:p", {}, [_run_element_with_text(text)]) -def _paragraph_with_style_id(style_id): - style_xml = xml_element("w:pStyle", {"w:val": style_id}) - properties_xml = xml_element("w:pPr", {}, [style_xml]) - return xml_element("w:p", {}, [properties_xml]) - def _run_element_with_text(text): return xml_element("w:r", {}, [_text_element(text)]) def _text_element(value): return xml_element("w:t", {}, [xml_text(value)]) - - -def _create_inline_image(description, relationship_id): - return xml_element("w:drawing", {}, [ - xml_element("wp:inline", {}, _create_image_elements(description, relationship_id)) - ]) - - -def _create_anchored_image(description, relationship_id): - return xml_element("w:drawing", {}, [ - xml_element("wp:anchor", {}, _create_image_elements(description, relationship_id)) - ]) - - -def _create_image_elements(description, relationship_id): - return [ - xml_element("wp:docPr", {"descr": description}), - xml_element("a:graphic", {}, [ - xml_element("a:graphicData", {}, [ - xml_element("pic:pic", {}, [ - xml_element("pic:blipFill", {}, [ - xml_element("a:blip", {"r:embed": relationship_id}) - ]) - ]) - ]) - ]) - ] -- cgit v1.2.3