(0, 0'
55 | )
56 |
--------------------------------------------------------------------------------
/tests/test_dropdown_selector_in_table.py:
--------------------------------------------------------------------------------
1 | """Test the dropdown selector in a table.
2 |
3 | Issue: [https://github.com/ShayHill/docx2python/issues/73]
4 |
5 | User iamahcy reports that a ContentControl dropdown selector in a table raises an
6 | error.
7 |
8 | The issue is that dropdown selectors are a nested table, and the first row of that
9 | table requests a vMerge. The fix was to reject any vMerge (copy the cell above)
10 | request in the first row of any table.
11 |
12 | :author: Shay Hill
13 | :created: 2024-09-26
14 | """
15 |
16 | from docx2python import docx2python
17 | from tests.conftest import RESOURCES
18 |
19 | test_file = RESOURCES / "list_index_a.docx"
20 |
21 |
22 | class TestContentControlDropdownSelectorInTable:
23 | def test_content_control_dropdown_selector_in_table(self):
24 | """Test the dropdown selector in a table."""
25 | with docx2python(test_file) as docx_content:
26 | content_runs = docx_content.document
27 |
28 | # fmt: off
29 | assert content_runs == [
30 | [
31 | [
32 | [""], [""], [""], [""], ["", ""]
33 | ],
34 | [
35 | [""], [""], [""], [""], ["", ""]
36 | ],
37 | [
38 | [""], [""], [""], [""], ["", ""]
39 | ],
40 | [
41 | [""], [""], [""], [""], ["", ""]
42 | ],
43 | [
44 | [""], [""], [""], [""], ["", ""]
45 | ],
46 | [
47 | [""]
48 | ],
49 | ],
50 | [
51 | [
52 | ["Silver"]
53 | ]
54 | ],
55 | [
56 | [
57 | [""], [""], [""]
58 | ],
59 | [
60 | ["", ""], ["", ""], ["", ""], ["", ""], ["", ""]
61 | ]
62 | ],
63 | [
64 | [
65 | [""]
66 | ]
67 | ],
68 | [
69 | [
70 | [""], [""]
71 | ]
72 | ],
73 | [
74 | [
75 | [""], [""]
76 | ]
77 | ],
78 | ]
79 | # fmt: on
80 |
--------------------------------------------------------------------------------
/tests/test_equations.py:
--------------------------------------------------------------------------------
1 | """Pull some information from equations
2 |
3 | :author: Shay Hill
4 | :created: 7/7/2021
5 |
6 | User sreeroopnaidu requested equation export. Equations are made up internally of
7 | elements. Previous versions of Docx2Python ignored these elements. These are
8 | now recognized.
9 |
10 | Equations in Word's Professional format will return garbage.
11 | Equations in Word's Inline format will return a nice string.
12 | """
13 |
14 | from docx2python import docx2python
15 | from tests.conftest import RESOURCES
16 |
17 |
18 | class TestEquations:
19 | def test_professional_format(self):
20 | """
21 | Start a new paragraph when a element is found.
22 | """
23 | with docx2python(RESOURCES / "equations.docx") as content:
24 | body = content.body
25 | assert body == [
26 | [
27 | [
28 | [
29 | "Professional Format",
30 | "01x",
31 | "Linear Format",
32 | "\\int_{0}^{1}x",
33 | "Linear Format with lt",
34 | "\\int0<1x<5",
35 | ]
36 | ]
37 | ]
38 | ]
39 |
--------------------------------------------------------------------------------
/tests/test_file_object.py:
--------------------------------------------------------------------------------
1 | """Test methods of File object that are not tested elsewhere.
2 |
3 | :author: Shay Hill
4 | :created: 4/3/2021
5 | """
6 |
7 | from docx2python.attribute_register import Tags, get_prefixed_tag
8 | from docx2python.docx_reader import DocxReader
9 | from docx2python.main import docx2python
10 | from tests.conftest import RESOURCES
11 |
12 |
13 | class TestFileObject:
14 | """
15 | Test methods of DocxContext object which are not tested elsewhere.
16 | """
17 |
18 | def test_get_content_full(self) -> None:
19 | """
20 | Return full content if no root given.
21 | """
22 | full_extraction = docx2python(RESOURCES / "example.docx")
23 | context = DocxReader(RESOURCES / "example.docx")
24 | assert (
25 | full_extraction.body_runs
26 | == context.file_of_type("officeDocument").get_text()
27 | )
28 | context.close()
29 | full_extraction.close()
30 |
31 | def test_get_content_partial(self) -> None:
32 | """
33 | Return content below root argument if given.
34 | """
35 | full_extraction = docx2python(RESOURCES / "example.docx")
36 | context = DocxReader(RESOURCES / "example.docx")
37 | document_xml = context.file_of_type("officeDocument")
38 | first_par = next(
39 | x
40 | for x in document_xml.root_element.iter()
41 | if get_prefixed_tag(x) == Tags.PARAGRAPH
42 | )
43 | assert [[[[full_extraction.body_runs[0][0][0][0]]]]] == document_xml.get_text(
44 | first_par
45 | )
46 | context.close()
47 | full_extraction.close()
48 |
--------------------------------------------------------------------------------
/tests/test_from_bytes.py:
--------------------------------------------------------------------------------
1 | """Test loading a .docx from a buffer of raw bytes.
2 |
3 | :author: Shay Hill
4 | :created: 2024-07-25
5 | """
6 |
7 | from io import BytesIO
8 |
9 | from docx2python.main import docx2python
10 | from tests.conftest import RESOURCES
11 |
12 | example_docx = RESOURCES / "example.docx"
13 |
14 |
15 | class TestFromBytes:
16 | def test_from_bytes(self) -> None:
17 | """Loads .docx from a buffer of raw bytes."""
18 | with open(example_docx, "rb") as f:
19 | buf = BytesIO(f.read())
20 | with docx2python(buf) as content:
21 | core_properties = content.core_properties
22 | expected = {
23 | "title": None,
24 | "subject": None,
25 | "creator": "Shay Hill",
26 | "keywords": None,
27 | "description": None,
28 | "lastModifiedBy": "Shay Hill",
29 | }
30 | for prop, value in expected.items():
31 | assert core_properties[prop] == value
32 |
--------------------------------------------------------------------------------
/tests/test_get_text.py:
--------------------------------------------------------------------------------
1 | """Test functions in docx2python.get_text.py
2 |
3 | author: Shay Hill
4 | created: 5/20/2019
5 |
6 | Does not test ``get_text``. ``get text`` is tested through source_old.
7 | """
8 |
9 | # pyright: reportPrivateUsage=false
10 |
11 | from __future__ import annotations
12 |
13 | from collections import defaultdict
14 | from typing import TypedDict
15 |
16 | import pytest
17 | from lxml import etree
18 |
19 | from docx2python.bullets_and_numbering import BulletGenerator, _increment_list_counter
20 | from docx2python.docx_context import NumIdAttrs
21 | from tests.helpers.utils import valid_xml
22 |
23 |
24 | class NumberingContext(TypedDict):
25 | numId2Atts: dict[str, list[NumIdAttrs]]
26 | numId2count: defaultdict[str, defaultdict[str, int]]
27 |
28 |
29 | class TestIncrementListCounter:
30 | """Test get_text.increment_list_counter"""
31 |
32 | def test_function(self) -> None:
33 | """Increments counter at ilvl, deletes deeper counters."""
34 | ilvl2count: defaultdict[str, int] = defaultdict(
35 | int, {str(x): x for x in range(1, 6)}
36 | )
37 | assert ilvl2count == {"1": 1, "2": 2, "3": 3, "4": 4, "5": 5}
38 | _ = _increment_list_counter(ilvl2count, "2")
39 | assert ilvl2count == {"1": 1, "2": 3}
40 |
41 |
42 | @pytest.fixture()
43 | def numbered_paragraphs() -> list[bytes]:
44 | """Seven numbered paragraphs, indented 0-6 ilvls."""
45 | paragraphs: list[str] = []
46 | for ilvl in range(7):
47 | paragraphs.append(
48 | ""
49 | + ''
52 | + ''
53 | + ""
54 | )
55 | return [valid_xml(x) for x in paragraphs]
56 |
57 |
58 | @pytest.fixture()
59 | def numbering_context() -> NumberingContext:
60 | """
61 |
62 | :return:
63 | """
64 | numId2Atts = {
65 | "1": [
66 | NumIdAttrs(fmt="bullet", start=None),
67 | NumIdAttrs(fmt="decimal", start=None),
68 | NumIdAttrs(fmt="lowerLetter", start=None),
69 | NumIdAttrs(fmt="upperLetter", start=None),
70 | NumIdAttrs(fmt="lowerRoman", start=None),
71 | NumIdAttrs(fmt="upperRoman", start=None),
72 | NumIdAttrs(fmt="undefined", start=None),
73 | ]
74 | }
75 | numId2count: defaultdict[str, defaultdict[str, int]] = defaultdict(
76 | lambda: defaultdict(int)
77 | )
78 | return {"numId2Atts": numId2Atts, "numId2count": numId2count}
79 |
80 |
81 | class TestGetBulletString:
82 | """Test strip_test.get_bullet_string"""
83 |
84 | def test_bullet(
85 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
86 | ) -> None:
87 | """Returns '-- ' for 'bullet'"""
88 |
89 | paragraph = etree.fromstring(numbered_paragraphs[0])[0][0]
90 | bullets = BulletGenerator(numbering_context["numId2Atts"])
91 | assert bullets.get_bullet(paragraph) == "--\t"
92 |
93 | def test_decimal(
94 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
95 | ) -> None:
96 | """
97 | Returns '1) ' for 'decimal'
98 | indented one tab
99 | """
100 | paragraph = etree.fromstring(numbered_paragraphs[1])[0][0]
101 | bullets = BulletGenerator(numbering_context["numId2Atts"])
102 | assert bullets.get_bullet(paragraph) == "\t1)\t"
103 |
104 | def test_lower_letter(
105 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
106 | ) -> None:
107 | """
108 | Returns 'a) ' for 'lowerLetter'
109 | indented two tabs
110 | """
111 | paragraph = etree.fromstring(numbered_paragraphs[2])[0][0]
112 | bullets = BulletGenerator(numbering_context["numId2Atts"])
113 | assert bullets.get_bullet(paragraph) == "\t\ta)\t"
114 |
115 | def test_upper_letter(
116 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
117 | ) -> None:
118 | """
119 | Returns 'A) ' for 'upperLetter'
120 | indented three tabs
121 | """
122 | paragraph = etree.fromstring(numbered_paragraphs[3])[0][0]
123 | bullets = BulletGenerator(numbering_context["numId2Atts"])
124 | assert bullets.get_bullet(paragraph) == "\t\t\tA)\t"
125 |
126 | def test_lower_roman(
127 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
128 | ) -> None:
129 | """
130 | Returns 'i) ' for 'lowerRoman'
131 | indented 4 tabs
132 | """
133 | paragraph = etree.fromstring(numbered_paragraphs[4])[0][0]
134 | bullets = BulletGenerator(numbering_context["numId2Atts"])
135 | assert bullets.get_bullet(paragraph) == "\t\t\t\ti)\t"
136 |
137 | def test_upper_roman(
138 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
139 | ) -> None:
140 | """
141 | Returns 'I) ' for 'upperRoman'
142 | indented 5 tabs
143 | """
144 | paragraph = etree.fromstring(numbered_paragraphs[5])[0][0]
145 | bullets = BulletGenerator(numbering_context["numId2Atts"])
146 | assert bullets.get_bullet(paragraph) == "\t\t\t\t\tI)\t"
147 |
148 | def test_undefined(
149 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
150 | ) -> None:
151 | """
152 | Returns '-- ' for unknown formats
153 | indented 6 tabs
154 |
155 | Format "undefined" won't be defined in the function, so function will fall back
156 | to bullet string (with a warning).
157 | """
158 | paragraph = etree.fromstring(numbered_paragraphs[6])[0][0]
159 | bullets = BulletGenerator(numbering_context["numId2Atts"])
160 | with pytest.warns(UserWarning):
161 | _ = bullets.get_bullet(paragraph)
162 |
163 | def test_not_numbered(self, numbering_context: NumberingContext) -> None:
164 | """
165 | Returns '' when paragraph is not numbered.
166 | """
167 | one_par_file = valid_xml("")
168 | paragraph = etree.fromstring(one_par_file)[0]
169 | bullets = BulletGenerator(numbering_context["numId2Atts"])
170 | assert bullets.get_bullet(paragraph) == ""
171 |
172 | def test_resets_sublists(
173 | self, numbered_paragraphs: list[bytes], numbering_context: NumberingContext
174 | ):
175 | """Numbers reset when returning to shallower level
176 |
177 | 1) top level
178 | a) level 2
179 | b) another level 2
180 | A) level 3
181 | c) level 2 is still counting
182 | A) NEW sublist of level 2
183 | 2) top level is still counting
184 | a) NEW sublist of top level
185 | """
186 | pars = [numbered_paragraphs[x] for x in (1, 2, 2, 3, 2, 3, 1, 2)]
187 | bullets = BulletGenerator(numbering_context["numId2Atts"])
188 | bullet_strings: list[str] = []
189 | for par in pars:
190 | paragraph = etree.fromstring(par)[0][0]
191 | bullet_strings.append(bullets.get_bullet(paragraph).strip())
192 |
193 | assert bullet_strings == ["1)", "a)", "b)", "A)", "c)", "A)", "2)", "a)"]
194 |
--------------------------------------------------------------------------------
/tests/test_google_docs.py:
--------------------------------------------------------------------------------
1 | """Test corrections for google docs docx files
2 |
3 | :author: Shay Hill
4 | :created: 11/2/2020
5 |
6 | Docx files created in MS Work have a ``docProps.xml`` file with author, etc.
7 | Docx files created in google docs do not have a ``docProps.xml`` file.
8 |
9 | File `test-docx2python-conversion-google_docs.docx` sent by a user.
10 |
11 | Traceback (most recent call last):
12 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/bin/word2md", line 33, in
13 | sys.exit(load_entry_point('word2md', 'console_scripts', 'word2md')())
14 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/lib/python3.8/site-packages/click/core.py", line 829, in call
15 | return self.main(*args, **kwargs)
16 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/lib/python3.8/site-packages/click/core.py", line 782, in main
17 | rv = self.invoke(ctx)
18 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/lib/python3.8/site-packages/click/core.py", line 1066, in invoke
19 | return ctx.invoke(self.callback, **ctx.params)
20 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/lib/python3.8/site-packages/click/core.py", line 610, in invoke
21 | return callback(*args, **kwargs)
22 | File "/Users/cyee/projects/python/word-to-md/word2md.py", line 349, in cli
23 | make_md_from_entire_doc(path)
24 | File "/Users/cyee/projects/python/word-to-md/word2md.py", line 300, in make_md_from_entire_doc
25 | document = docx2python(input_file, html=True)
26 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/lib/python3.8/site-packages/docx2python/main.py", line 35, in docx2python
27 | context = get_context(zipf)
28 | File "/Users/cyee/.local/share/virtualenvs/word-to-md-EFw2UvDn/lib/python3.8/site-packages/docx2python/docx_context.py", line 272, in get_context
29 | "docProp2text": collect_docProps(zipf.read("docProps/core.xml")),
30 | File "/usr/local/opt/python@3.8/Frameworks/Python.framework/Versions/3.8/lib/python3.8/zipfile.py", line 1475, in read
31 | with self.open(name, "r", pwd) as fp:
32 | File "/usr/local/opt/python@3.8/Frameworks/Python.framework/Versions/3.8/lib/python3.8/zipfile.py", line 1514, in open
33 | zinfo = self.getinfo(name)
34 | File "/usr/local/opt/python@3.8/Frameworks/Python.framework/Versions/3.8/lib/python3.8/zipfile.py", line 1441, in getinfo
35 | raise KeyError(
36 | KeyError: "There is no item named 'docProps/core.xml' in the archive"
37 | """
38 |
39 | import pytest
40 |
41 | from docx2python import docx2python
42 | from tests.conftest import RESOURCES
43 |
44 | FILE_WITH_DOCPROPS = RESOURCES / "example.docx"
45 |
46 | FILE_WITHOUT_DOCPROPS = RESOURCES / "test-docx2python-conversion-google_docs.docx"
47 |
48 |
49 | class TestDeprecatedPropertiesProperty:
50 | def test_deprecated_properties_property(self) -> None:
51 | """
52 | Raise a future warning when user requests ``result.properties``
53 | """
54 | with docx2python(FILE_WITH_DOCPROPS) as result:
55 | with pytest.warns(FutureWarning):
56 | _ = result.properties
57 |
58 |
59 | class TestDocPropsFound:
60 | def test_docprops_found(self) -> None:
61 | """
62 | Return docProps as a dictionary
63 | """
64 | with docx2python(FILE_WITH_DOCPROPS) as result:
65 | assert result.core_properties == {
66 | "created": "2019-07-05T21:51:00Z",
67 | "creator": "Shay Hill",
68 | "description": None,
69 | "keywords": None,
70 | "lastModifiedBy": "Shay Hill",
71 | "modified": "2021-03-26T00:30:00Z",
72 | "revision": "7",
73 | "subject": None,
74 | "title": None,
75 | }
76 |
77 |
78 | class TestGoogleDocs:
79 | def test_empty_properties_dict_if_docProps_not_found(self) -> None:
80 | """
81 | It seems Google Docs docx files to not contain a document properties file:
82 | `docProps/core.xml`. The contents of this file are returned as a dictionary.
83 | To correct the above error, result.properties will now return an empty
84 | dictionary (with a warning).
85 | """
86 | with docx2python(FILE_WITHOUT_DOCPROPS) as result:
87 | with pytest.warns(UserWarning):
88 | assert result.core_properties == {}
89 |
--------------------------------------------------------------------------------
/tests/test_hyperlinks.py:
--------------------------------------------------------------------------------
1 | """Test that consecutive links pointing to the same address are merged.
2 |
3 | :author: Shay Hill
4 | :created: 3/17/2021
5 |
6 | Such links will look like this (after removing proofErr, rsid, and other noise).
7 |
8 |
9 |
10 |
11 | hy
12 |
13 |
14 |
15 |
16 | per
17 |
18 |
19 |
20 |
21 | link
22 |
23 |
24 |
25 |
26 | Docx2python condenses these to
27 |
28 |
29 |
30 |
31 | hy
32 |
33 |
34 | per
35 |
36 |
37 | link
38 |
39 |
40 |
41 |
42 | Then to
43 |
44 |
45 |
46 |
47 | hyperlink
48 |
49 |
50 |
51 |
52 | This module tests the final result.
53 | """
54 |
55 | from docx2python.main import docx2python
56 | from tests.conftest import RESOURCES
57 |
58 |
59 | class TestHyperlink:
60 | def test_prints(self) -> None:
61 | """Consecutive hyperlinks referencing same target are joined"""
62 | with docx2python(RESOURCES / "hyperlink.docx") as extraction:
63 | assert extraction.body_runs == [
64 | [
65 | [
66 | [
67 | [
68 | "This is a link to ",
69 | ''
70 | + "my website",
71 | ".",
72 | ]
73 | ]
74 | ]
75 | ]
76 | ]
77 |
--------------------------------------------------------------------------------
/tests/test_import.py:
--------------------------------------------------------------------------------
1 | """Make sure from docx2python import ... works
2 |
3 | :author: Shay Hill
4 | :created: 7/17/2019
5 |
6 | """
7 |
8 | from docx2python import docx2python
9 | from tests.conftest import RESOURCES
10 |
11 |
12 | def test() -> None:
13 | """Just making sure the import works."""
14 | with docx2python(RESOURCES / "example.docx") as _:
15 | pass
16 |
--------------------------------------------------------------------------------
/tests/test_invalid_tag_name.py:
--------------------------------------------------------------------------------
1 | """Issue 72: Invalid tag name.
2 |
3 | User makretch found a file converted by Aspose that had an invalid tag name in a
4 | comment. This tag name caused a ValueError when passed to `etree.QName`.
5 |
6 | ValueError: Invalid tag name 'cyfunction Comment at 0x12345678abcd'
7 |
8 | I addressed this by skipping elements with invalid tag names and raising a warning.
9 |
10 | :author: Shay Hill
11 | :created: 2024-12-05
12 | """
13 |
14 | import pytest
15 | from conftest import RESOURCES
16 |
17 | from docx2python import docx2python
18 |
19 |
20 | class TestInvalidTagName:
21 | """Confirming this works with v1.25"""
22 |
23 | def test_invalid_tag_name(self) -> None:
24 | """Pass if no ValueError is raised."""
25 | extraction = docx2python(RESOURCES / "invalid_tag_name.docx")
26 | with pytest.warns(UserWarning, match="skipping invalid tag name"):
27 | _ = extraction.text
28 | extraction.close()
29 |
--------------------------------------------------------------------------------
/tests/test_iterators.py:
--------------------------------------------------------------------------------
1 | """Test docx2python.iterators.py
2 |
3 | author: Shay Hill
4 | created: 6/28/2019
5 | """
6 |
7 | import itertools as it
8 |
9 | import pytest
10 |
11 | from docx2python.iterators import (
12 | enum_at_depth,
13 | enum_cells,
14 | enum_paragraphs,
15 | enum_rows,
16 | enum_tables,
17 | get_html_map,
18 | iter_cells,
19 | iter_paragraphs,
20 | iter_rows,
21 | iter_tables,
22 | )
23 |
24 | TABLES = [
25 | [
26 | [[["0000", "0001"], ["0010", "0011"]], [["0100", "0101"], ["0110", "0111"]]],
27 | [[["1000", "1001"], ["1010", "1011"]], [["1100", "1101"], ["1110", "1111"]]],
28 | ]
29 | ]
30 |
31 |
32 | class TestOutOfRange:
33 | def test_enum_at_depth_low(self) -> None:
34 | """Raise ValueError when attempting to enumerate over depth < 1."""
35 | with pytest.raises(ValueError) as msg:
36 | _ = tuple(enum_at_depth(TABLES, 0)) # type: ignore
37 | assert "depth argument must be 1, 2, 3, 4, or 5" in str(msg.value)
38 |
39 | def test_enum_at_depth_high(self) -> None:
40 | """Raise ValueError when attempting to enumerate over depth < 1."""
41 | with pytest.raises(ValueError) as msg:
42 | _ = tuple(enum_at_depth(TABLES, 6)) # type: ignore
43 | assert "depth argument must be 1, 2, 3, 4, or 5" in str(msg.value)
44 |
45 |
46 | class TestIterators:
47 | """Test iterators.iter_*"""
48 |
49 | def test_iter_tables(self) -> None:
50 | """Return all tables."""
51 | assert list(iter_tables(TABLES)) == TABLES
52 |
53 | def test_iter_rows(self) -> None:
54 | """Return all rows."""
55 | assert list(iter_rows(TABLES)) == list(it.chain(*iter_tables(TABLES)))
56 |
57 | def test_iter_cells(self) -> None:
58 | """Return all cells."""
59 | assert list(iter_cells(TABLES)) == list(it.chain(*iter_rows(TABLES)))
60 |
61 | def test_iter_paragraphs(self) -> None:
62 | """Return all paragraphs."""
63 | assert list(iter_paragraphs(TABLES)) == list(it.chain(*iter_cells(TABLES)))
64 |
65 |
66 | class TestEnumerators:
67 | """Test iterators.enum_*"""
68 |
69 | def test_enum_tables(self) -> None:
70 | """Return all tables."""
71 | assert list(enum_tables(TABLES)) == [
72 | (
73 | (0,),
74 | [
75 | [
76 | [["0000", "0001"], ["0010", "0011"]],
77 | [["0100", "0101"], ["0110", "0111"]],
78 | ],
79 | [
80 | [["1000", "1001"], ["1010", "1011"]],
81 | [["1100", "1101"], ["1110", "1111"]],
82 | ],
83 | ],
84 | )
85 | ]
86 |
87 | def test_enum_rows(self) -> None:
88 | """Return all rows."""
89 | assert list(enum_rows(TABLES)) == [
90 | (
91 | (0, 0),
92 | [
93 | [["0000", "0001"], ["0010", "0011"]],
94 | [["0100", "0101"], ["0110", "0111"]],
95 | ],
96 | ),
97 | (
98 | (0, 1),
99 | [
100 | [["1000", "1001"], ["1010", "1011"]],
101 | [["1100", "1101"], ["1110", "1111"]],
102 | ],
103 | ),
104 | ]
105 |
106 | def test_enum_cells(self) -> None:
107 | """Return all cells."""
108 | assert list(enum_cells(TABLES)) == [
109 | ((0, 0, 0), [["0000", "0001"], ["0010", "0011"]]),
110 | ((0, 0, 1), [["0100", "0101"], ["0110", "0111"]]),
111 | ((0, 1, 0), [["1000", "1001"], ["1010", "1011"]]),
112 | ((0, 1, 1), [["1100", "1101"], ["1110", "1111"]]),
113 | ]
114 |
115 | def test_enum_paragraphs(self) -> None:
116 | """Return all paragraphs."""
117 | assert list(enum_paragraphs(TABLES)) == [
118 | ((0, 0, 0, 0), ["0000", "0001"]),
119 | ((0, 0, 0, 1), ["0010", "0011"]),
120 | ((0, 0, 1, 0), ["0100", "0101"]),
121 | ((0, 0, 1, 1), ["0110", "0111"]),
122 | ((0, 1, 0, 0), ["1000", "1001"]),
123 | ((0, 1, 0, 1), ["1010", "1011"]),
124 | ((0, 1, 1, 0), ["1100", "1101"]),
125 | ((0, 1, 1, 1), ["1110", "1111"]),
126 | ]
127 |
128 |
129 | class TestGetHtmlMap:
130 | """Test iterators.get_html_map"""
131 |
132 | def test_get_html_map(self) -> None:
133 | """Create valid html."""
134 | # fmt: off
135 | assert get_html_map(TABLES) == (
136 | ""
137 | ""
138 | ''
139 | ""
140 | ""
141 | "(0, 0, 0, 0) 00000001"
142 | " "
143 | "(0, 0, 0, 1) 00100011"
144 | " "
145 | " | "
146 | ""
147 | "(0, 0, 1, 0) 01000101"
148 | " "
149 | "(0, 0, 1, 1) 01100111"
150 | " "
151 | " | "
152 | " "
153 | ""
154 | ""
155 | "(0, 1, 0, 0) 10001001"
156 | " "
157 | "(0, 1, 0, 1) 10101011"
158 | " "
159 | " | "
160 | ""
161 | "(0, 1, 1, 0) 11001101"
162 | " "
163 | "(0, 1, 1, 1) 11101111"
164 | " "
165 | " | "
166 | " "
167 | " "
168 | ""
169 | ""
170 | )
171 | # fmt: on
172 |
--------------------------------------------------------------------------------
/tests/test_libreoffice_conversion.py:
--------------------------------------------------------------------------------
1 | """Libreoffice conversions from doc to docx raise CaretDepthError
2 |
3 | :author: Shay Hill
4 | :created: 8/11/2021
5 |
6 | Uner shadowmimosa shared a docx (libreoffice_conversion.docx), converted by libreoffice
7 | from a doc that raises a CaretDepthError.
8 | """
9 |
10 | import pytest
11 |
12 | from docx2python.main import docx2python
13 | from tests.conftest import RESOURCES
14 |
15 |
16 | class TestLibreofficeConversion:
17 | def test_libreoffice_conversion(self) -> None:
18 | """Extracts text without a CaretDepthError
19 |
20 | This test file for a user just happens to be in Chinese and contains an
21 | unsupported Chinese numbering format, hence the ``pytest.warns`` context.
22 | """
23 | with docx2python(RESOURCES / "libreoffice_conversion.docx") as content:
24 | with pytest.warns(UserWarning):
25 | _ = content.document
26 |
--------------------------------------------------------------------------------
/tests/test_lineage.py:
--------------------------------------------------------------------------------
1 | """Test the lineage attribute of Par instances.
2 |
3 | :author: Shay Hill
4 | :created: 2024-07-14
5 | """
6 |
7 | from docx2python.iterators import (
8 | is_tbl,
9 | is_tc,
10 | is_tr,
11 | iter_cells,
12 | iter_paragraphs,
13 | iter_rows,
14 | iter_tables,
15 | )
16 | from docx2python.main import docx2python
17 |
18 | from .conftest import RESOURCES
19 |
20 |
21 | class TestLineage:
22 | """Are lineage tags correct for Par instances?"""
23 |
24 | def test_explicit(self):
25 | """Output matches expected lineage."""
26 | with docx2python(RESOURCES / "paragraphs_and_tables.docx") as extraction:
27 | pars = extraction.document_pars
28 | lineages = [par.lineage for par in iter_paragraphs(pars)]
29 | assert lineages == [
30 | ("document", None, None, None, "p"),
31 | ("document", "tbl", "tr", "tc", "p"),
32 | ("document", "tbl", "tr", "tc", "p"),
33 | ("document", "tbl", "tr", "tc", "p"),
34 | ("document", "tbl", "tr", "tc", "p"),
35 | ("document", "tbl", "tr", "tc", "p"),
36 | ("document", "tbl", "tr", "tc", "p"),
37 | ("document", None, None, None, "p"),
38 | ("document", None, None, None, "p"),
39 | ("document", "tbl", "tr", "tc", "p"),
40 | ("document", "tbl", "tr", "tc", "p"),
41 | ("document", "tbl", "tr", "tc", "p"),
42 | ("document", "tbl", "tr", "tc", "p"),
43 | ("document", None, None, None, "p"),
44 | ]
45 |
46 |
47 | class TestTableIdentification:
48 | """Are tables identified correctly?"""
49 |
50 | def test_is_tbl(self):
51 | """Tables are identified correctly."""
52 | with docx2python(RESOURCES / "paragraphs_and_tables.docx") as extraction:
53 | pars = extraction.document_pars
54 | assert [is_tbl(tbl) for tbl in iter_tables(pars)] == [
55 | False,
56 | True,
57 | False,
58 | True,
59 | False,
60 | ]
61 |
62 | def test_is_tr(self):
63 | """Tables are identified correctly."""
64 | with docx2python(RESOURCES / "paragraphs_and_tables.docx") as extraction:
65 | pars = extraction.document_pars
66 | assert [is_tr(tr) for tr in iter_rows(pars)] == [
67 | False,
68 | True,
69 | True,
70 | True,
71 | False,
72 | True,
73 | True,
74 | True,
75 | True,
76 | False,
77 | ]
78 |
79 | def test_is_tc(self):
80 | """Tables are identified correctly."""
81 | with docx2python(RESOURCES / "paragraphs_and_tables.docx") as extraction:
82 | pars = extraction.document_pars
83 | assert [is_tc(tc) for tc in iter_cells(pars)] == [
84 | False,
85 | True,
86 | True,
87 | True,
88 | True,
89 | True,
90 | True,
91 | False,
92 | True,
93 | True,
94 | True,
95 | True,
96 | False,
97 | ]
98 |
--------------------------------------------------------------------------------
/tests/test_linebreak_replace_text.py:
--------------------------------------------------------------------------------
1 | """Try to use replace text with a linebreak.
2 |
3 | :author: Shay Hill
4 | :created: 2023-04-26
5 | """
6 |
7 | from docx2python.main import docx2python
8 | from tests.conftest import RESOURCES
9 |
10 |
11 | class TestText:
12 | def test_user_checked_dropdown0(self) -> None:
13 | """Get checked-out box glyph and second dd entry"""
14 | extraction = docx2python(RESOURCES / "checked_drop1.docx")
15 | assert extraction.body_runs == [[[[["☒", " "], ["PIlihan A"]]]]]
16 | extraction.close()
17 |
--------------------------------------------------------------------------------
/tests/test_list_position.py:
--------------------------------------------------------------------------------
1 | """Test list_position attribute of list paragraphs.
2 |
3 | :author: Shay Hill
4 | :created: 2024-07-17
5 | """
6 |
7 | from docx2python.iterators import iter_at_depth
8 | from docx2python.main import docx2python
9 | from tests.conftest import RESOURCES
10 |
11 |
12 | class TestListPosition:
13 | def test_explicit(self):
14 | # """List paragraphs match hand-counted list_position."""
15 | with docx2python(RESOURCES / "example.docx") as content:
16 | pars = iter_at_depth(content.officeDocument_pars, 4)
17 | positions = [p.list_position for p in pars]
18 | assert positions == [
19 | ("2", [1]),
20 | ("2", [1, 1]),
21 | ("2", [1, 2]),
22 | ("2", [1, 2, 1]),
23 | ("2", [1, 2, 1, 1]),
24 | ("2", [1, 2, 1, 2]),
25 | ("2", [1, 2, 1, 2, 1]),
26 | ("2", [1, 2, 1, 2, 1, 1]),
27 | ("2", [1, 2, 1, 2, 1, 1, 1]),
28 | ("2", [1, 2, 1, 2, 1, 1, 2]),
29 | ("2", [2]),
30 | ("2", [2, 1]),
31 | ("1", [1]),
32 | ("1", [1, 1]),
33 | ("1", [1, 1, 1]),
34 | (None, []),
35 | (None, []),
36 | (None, []),
37 | (None, []),
38 | (None, []),
39 | (None, []),
40 | (None, []),
41 | (None, []),
42 | (None, []),
43 | (None, []),
44 | (None, []),
45 | (None, []),
46 | (None, []),
47 | (None, []),
48 | (None, []),
49 | (None, []),
50 | (None, []),
51 | (None, []),
52 | (None, []),
53 | (None, []),
54 | (None, []),
55 | (None, []),
56 | (None, []),
57 | (None, []),
58 | ]
59 |
--------------------------------------------------------------------------------
/tests/test_long_hyperlink.py:
--------------------------------------------------------------------------------
1 | """User K Ravikiran had trouble with long hyperlinks.
2 |
3 | The sample file here has a hyperlink he was not able to export correctly.
4 |
5 | :author: Shay Hill
6 | :created: 2024-01-20
7 | """
8 |
9 | from docx2python.main import docx2python
10 | from tests.conftest import RESOURCES
11 |
12 | long_hyperlink = RESOURCES / "long_hyperlink.docx"
13 |
14 |
15 | class TestLongHyperlink:
16 | def test_non_html(self) -> None:
17 | """Exports full hyperlink without html flag."""
18 | with docx2python(long_hyperlink) as docx_content:
19 | extracted_text = docx_content.text
20 | long_url = (
21 | "https://connect.asdfg.com/wikis/home?lang-en-us"
22 | + "#!/wiki/asdfasdf_asdfasdf/page/EOL%20support%20-%20MDGI"
23 | )
24 | assert long_url in extracted_text
25 |
26 | def test_html(self) -> None:
27 | """Exports full hyperlink with html flag."""
28 | with docx2python(long_hyperlink, html=True) as docx_content:
29 | extracted_text = docx_content.text
30 | long_url = (
31 | "https://connect.asdfg.com/wikis/home?lang-en-us"
32 | + "#!/wiki/asdfasdf_asdfasdf/page/EOL%20support%20-%20MDGI"
33 | )
34 | assert long_url in extracted_text
35 |
--------------------------------------------------------------------------------
/tests/test_merge_runs.py:
--------------------------------------------------------------------------------
1 | """Test that consecutive links pointing to the same address are merged.
2 |
3 | :author: Shay Hill
4 | :created: 3/17/2021
5 |
6 | There are a few ways consecutive elements can be "identical":
7 | * same link
8 | * same style
9 |
10 | Often, consecutive, "identical" elements are written as separate elements,
11 | because they aren't identical to Word. Work keeps track of revision history,
12 | spelling errors, etc., which are meaningless to docx2python.
13 |
14 |
15 |
16 |
17 | hy
18 |
19 |
20 |
21 |
22 |
23 | per
24 |
25 |
26 |
27 |
28 | link
29 |
30 |
31 |
32 |
33 | Docx2python condenses the above to (by merging links)
34 |
35 |
36 |
37 |
38 | hy
39 |
40 |
41 | per
42 |
43 |
44 | link
45 |
46 |
47 |
48 |
49 | Then to (by merging runs)
50 |
51 |
52 |
53 |
54 | hy
55 | per
56 | link
57 |
58 |
59 |
60 |
61 | Then finally to (by merging text)
62 |
63 |
64 |
65 |
66 | hyperlink
67 |
68 |
69 |
70 | """
71 |
72 | from docx2python.main import docx2python
73 | from tests.conftest import RESOURCES
74 |
75 |
76 | def test_merge_runs():
77 | """
78 | Merge duplicate, consecutive hyperlinks
79 |
80 | The output text would look the same whether run and text elements were merged.
81 | This test only verifies that hyperlink elements have been merged, else the output
82 | text would contain something closer to ``hyperlink``
83 | """
84 | extraction = docx2python(RESOURCES / "merged_links.docx")
85 | assert extraction.body_runs == [
86 | [
87 | [
88 | [
89 | [
90 | "This page created by putting three links to the same address "
91 | + "in three different paragraphs (as below) …"
92 | ],
93 | ['hy'],
94 | ['per'],
95 | ['link'],
96 | ["Then removing the endlines to create a single link."],
97 | ['hyperlink'],
98 | [
99 | "Internally, the XML records the joined paragraphs as "
100 | + "three consecutive links, each with a different r:id, "
101 | + "all r:ids referencing the same address. Docx2python v2+ "
102 | + "should re-join these consecutive links."
103 | ],
104 | [],
105 | [],
106 | ]
107 | ]
108 | ]
109 | ]
110 | extraction.close()
111 |
--------------------------------------------------------------------------------
/tests/test_merged_cells.py:
--------------------------------------------------------------------------------
1 | """Attempt to properly handle merged table cells.
2 |
3 | :author: Shay Hill
4 | :created: 2023-01-23
5 | """
6 |
7 | from docx2python import docx2python
8 | from tests.conftest import RESOURCES
9 |
10 |
11 | class TestMergedCells:
12 | def test_duplicate_merged_cells_false(self):
13 | """By default, duplicate merged cells."""
14 | with docx2python(
15 | RESOURCES / "merged_cells.docx", duplicate_merged_cells=False
16 | ) as content:
17 | # fmt: off
18 | assert content.body == [
19 | [
20 | [["0-0"], ["0-12"], [""], ["0-3"]],
21 | [["12-0"], ["1-1"], ["1-2"], ["1-3"]],
22 | [[""], ["2-1"], ["2-2"], ["2-3"]],
23 | [["3-0"], ["34-123"], [""], [""]],
24 | [["4-0"], [""], [""], [""]],
25 | ],
26 | [[[""]]],
27 | ]
28 | # fmt: on
29 |
30 | def test_duplicate_merged_cells_true(self):
31 | """Duplicate contents in merged cells for an mxn table list."""
32 | with docx2python(RESOURCES / "merged_cells.docx") as content:
33 | # fmt: off
34 | assert content.body == [
35 | [
36 | [["0-0"], ["0-12"], ["0-12"], ["0-3"]],
37 | [["12-0"], ["1-1"], ["1-2"], ["1-3"]],
38 | [["12-0"], ["2-1"], ["2-2"], ["2-3"]],
39 | [["3-0"], ["34-123"], ["34-123"], ["34-123"]],
40 | [["4-0"], ["34-123"], ["34-123"], ["34-123"]],
41 | ],
42 | [[[""]]],
43 | ]
44 | # fmt: on
45 |
--------------------------------------------------------------------------------
/tests/test_more_html.py:
--------------------------------------------------------------------------------
1 | """Test that passing `more_html = True` collects paragraph styles
2 |
3 | :author: Shay Hill
4 | :created: 11/5/2020
5 |
6 | Paragraphs and runs can end up nested with text boxes. Docx2python
7 | un-nests these paragraphs.
8 |
9 |
10 |
11 |
12 |
13 |
14 | EHS Manual
15 |
16 |
17 |
18 |
19 | EHS Manual
20 |
21 |
22 |
24 |
25 | EHS Manual
26 |
27 |
28 |
29 |
30 | EHS Manual
31 |
32 |
33 | ```
34 |
35 | par 1 text
36 |
37 | par 2 text
38 |
39 | more par 1 text
40 |
41 | ```
42 |
43 | gets flattened to
44 |
45 | ```
46 | `par 2 text`
47 | 'par 1 text`
48 | `more par 1 text`
49 | ```
50 | Paragraphs are returned in by the order in which they *close*.
51 |
52 |
53 |
54 |
55 |
56 |
57 |
58 |
59 |
60 |
61 |
62 |
63 |
64 |
65 |
66 |
67 |
68 | EHS Manual
69 |
70 |
71 |
72 |
73 |
74 |
75 |
76 |
77 |
78 |
79 | """
80 |
81 | from paragraphs import par
82 |
83 | from docx2python.iterators import iter_at_depth
84 | from docx2python.main import docx2python
85 | from tests.conftest import RESOURCES
86 |
87 |
88 | def test_paragraphs_only() -> None:
89 | """Html tags inserted into text"""
90 | with docx2python(RESOURCES / "nested_paragraphs.docx", html=True) as extraction:
91 | document_pars = extraction.document_pars
92 | styled = [(p.style, p.run_strings) for p in iter_at_depth(document_pars, 4)]
93 | expect = [
94 | (
95 | "",
96 | [
97 | par(
98 | """[Grab your reader’s attention with a great quote from the
99 | document or use this space to emphasize a key point. To place
100 | this text box anywhere on the page, just drag it.]"""
101 | )
102 | ],
103 | ),
104 | (
105 | "",
106 | [
107 | par(
108 | """[Grab your reader’s attention with a great quote from the
109 | document or use this space to emphasize a key point. To place
110 | this text box anywhere on the page, just drag it.]"""
111 | )
112 | ],
113 | ),
114 | (
115 | "Heading1",
116 | [
117 | "",
118 | par(
119 | """aaa aab aac aad aae aaf aag aah aai aaj aak aal aam aan aao
120 | aap aaq aar aas aat aau aav aaw aax aay aaz aba abb abc abd abe
121 | abf abg abh abi abj abk abl abm abn abo abp abq abr abs abt abu
122 | abv abw abx aby abz aca acb acc acd ace acf acg ach aci acj ack
123 | acl acm acn aco acp acq acr acs act acu acv acw acx acy acz ada
124 | adb adc add ade adf adg adh adi adj adk adl adm adn ado adp adq
125 | adr ads adt adu adv adw adx ady adz aea aeb aec aed aee aef aeg
126 | aeh aei aej aek ael aem aen aeo aep aeq aer aes aet aeu aev aew
127 | aex aey aez afa afb afc afd afe aff afg afh afi afj afk afl afm
128 | afn afo afp afq afr afs aft afu afv afw afx afy afz aga agb agc
129 | agd age agf agg agh agi agj agk agl agm agn ago agp agq agr ags
130 | agt agu agv agw agx agy agz aha ahb ahc ahd ahe ahf ahg ahh ahi
131 | ahj ahk ahl ahm ahn aho ahp ahq ahr ahs aht ahu ahv ahw ahx ahy
132 | ahz aia aib aic aid aie aif aig aih aii aij aik ail aim ain aio
133 | aip aiq air ais ait aiu aiv aiw aix aiy aiz aja ajb ajc ajd aje
134 | ajf ajg ajh aji ajj ajk ajl ajm ajn ajo ajp ajq ajr ajs ajt aju
135 | ajv ajw ajx ajy ajz aka akb akc akd ake akf akg akh aki akj akk
136 | akl akm akn ako akp akq akr aks akt aku akv akw akx aky akz ala
137 | alb alc ald ale alf alg alh ali alj alk all alm aln alo alp alq
138 | alr als alt alu alv alw alx aly alz ama amb amc amd ame amf amg
139 | amh ami amj amk aml amm amn amo amp amq amr ams amt amu amv amw
140 | amx amy amz ana anb anc and ane anf ang anh ani anj ank anl anm
141 | ann ano anp anq anr ans ant anu anv anw anx any anz aoa aob aoc
142 | aod aoe aof aog aoh aoi aoj aok aol aom aon aoo aop aoq aor aos
143 | aot aou aov aow aox aoy aoz apa apb apc apd ape apf apg aph api
144 | apj apk apl apm apn apo app apq apr aps apt apu apv apw apx apy
145 | apz aqa aqb aqc aqd aqe aqf aqg aqh aqi aqj aqk aql aqm aqn aqo
146 | aqp aqq aqr aqs aqt aqu aqv aqw aqx aqy aqz ara arb arc ard are
147 | arf arg arh ari arj ark arl arm arn aro arp arq arr ars art aru
148 | arv arw arx ary arz asa asb asc asd ase asf asg ash asi asj ask
149 | asl asm asn aso asp asq asr ass ast asu asv asw asx asy asz ata
150 | atb atc atd ate atf atg ath ati atj atk atl atm atn ato atp atq
151 | atr ats att atu atv atw atx aty atz aua aub auc aud aue auf aug
152 | auh aui auj auk aul aum aun auo aup auq aur aus aut auu auv auw
153 | aux auy auz ava avb avc avd ave avf avg avh avi avj avk avl avm
154 | avn avo avp avq avr avs avt avu avv avw avx avy avz awa awb awc
155 | awd awe awf awg awh awi awj awk awl awm awn awo awp awq awr aws
156 | awt awu awv aww awx awy awz axa axb axc axd axe axf axg axh axi
157 | axj axk axl axm axn axo axp axq axr axs axt axu axv axw axx axy
158 | axz aya ayb ayc ayd aye ayf ayg ayh ayi ayj ayk ayl aym ayn ayo
159 | ayp ayq ayr ays ayt ayu ayv ayw ayx ayy ayz aza azb azc azd aze
160 | azf azg azh azi azj azk azl azm azn azo azp azq azr azs azt azu
161 | azv azw azx azy azz"""
162 | ),
163 | "",
164 | ],
165 | ),
166 | ]
167 | assert styled == expect
168 |
169 |
170 | def test_par_styles_not_in_text() -> None:
171 | """Par styles skipped in pure text export"""
172 | pars = docx2python(RESOURCES / "nested_paragraphs.docx", html=True)
173 | assert pars.text == par(
174 | """[Grab your reader’s attention with a great quote from the document or use
175 | this space to emphasize a key point. To place this text box anywhere on the
176 | page, just drag it.]
177 |
178 | [Grab your reader’s attention with a great quote from the document or use
179 | this space to emphasize a key point. To place this text box anywhere on the
180 | page, just drag it.]
181 |
182 | aaa aab aac aad aae aaf aag aah aai aaj aak aal aam aan aao aap aaq aar
183 | aas aat aau aav aaw aax aay aaz aba abb abc abd abe abf abg abh abi abj abk
184 | abl abm abn abo abp abq abr abs abt abu abv abw abx aby abz aca acb acc acd
185 | ace acf acg ach aci acj ack acl acm acn aco acp acq acr acs act acu acv acw
186 | acx acy acz ada adb adc add ade adf adg adh adi adj adk adl adm adn ado adp
187 | adq adr ads adt adu adv adw adx ady adz aea aeb aec aed aee aef aeg aeh aei
188 | aej aek ael aem aen aeo aep aeq aer aes aet aeu aev aew aex aey aez afa afb
189 | afc afd afe aff afg afh afi afj afk afl afm afn afo afp afq afr afs aft afu
190 | afv afw afx afy afz aga agb agc agd age agf agg agh agi agj agk agl agm agn
191 | ago agp agq agr ags agt agu agv agw agx agy agz aha ahb ahc ahd ahe ahf ahg
192 | ahh ahi ahj ahk ahl ahm ahn aho ahp ahq ahr ahs aht ahu ahv ahw ahx ahy ahz
193 | aia aib aic aid aie aif aig aih aii aij aik ail aim ain aio aip aiq air ais
194 | ait aiu aiv aiw aix aiy aiz aja ajb ajc ajd aje ajf ajg ajh aji ajj ajk ajl
195 | ajm ajn ajo ajp ajq ajr ajs ajt aju ajv ajw ajx ajy ajz aka akb akc akd ake
196 | akf akg akh aki akj akk akl akm akn ako akp akq akr aks akt aku akv akw akx
197 | aky akz ala alb alc ald ale alf alg alh ali alj alk all alm aln alo alp alq
198 | alr als alt alu alv alw alx aly alz ama amb amc amd ame amf amg amh ami amj
199 | amk aml amm amn amo amp amq amr ams amt amu amv amw amx amy amz ana anb anc
200 | and ane anf ang anh ani anj ank anl anm ann ano anp anq anr ans ant anu anv
201 | anw anx any anz aoa aob aoc aod aoe aof aog aoh aoi aoj aok aol aom aon aoo
202 | aop aoq aor aos aot aou aov aow aox aoy aoz apa apb apc apd ape apf apg aph
203 | api apj apk apl apm apn apo app apq apr aps apt apu apv apw apx apy apz aqa
204 | aqb aqc aqd aqe aqf aqg aqh aqi aqj aqk aql aqm aqn aqo aqp aqq aqr aqs aqt
205 | aqu aqv aqw aqx aqy aqz ara arb arc ard are arf arg arh ari arj ark arl arm
206 | arn aro arp arq arr ars art aru arv arw arx ary arz asa asb asc asd ase asf
207 | asg ash asi asj ask asl asm asn aso asp asq asr ass ast asu asv asw asx asy
208 | asz ata atb atc atd ate atf atg ath ati atj atk atl atm atn ato atp atq atr
209 | ats att atu atv atw atx aty atz aua aub auc aud aue auf aug auh aui auj auk
210 | aul aum aun auo aup auq aur aus aut auu auv auw aux auy auz ava avb avc avd
211 | ave avf avg avh avi avj avk avl avm avn avo avp avq avr avs avt avu avv avw
212 | avx avy avz awa awb awc awd awe awf awg awh awi awj awk awl awm awn awo awp
213 | awq awr aws awt awu awv aww awx awy awz axa axb axc axd axe axf axg axh axi
214 | axj axk axl axm axn axo axp axq axr axs axt axu axv axw axx axy axz aya ayb
215 | ayc ayd aye ayf ayg ayh ayi ayj ayk ayl aym ayn ayo ayp ayq ayr ays ayt ayu
216 | ayv ayw ayx ayy ayz aza azb azc azd aze azf azg azh azi azj azk azl azm azn
217 | azo azp azq azr azs azt azu azv azw azx azy azz"""
218 | )
219 | pars.close()
220 |
221 |
222 | class TestBulletedLists:
223 | """Replace numbering format with bullet (--) when format cannot be determined"""
224 |
225 | def test_bulleted_lists(self) -> None:
226 | pars = docx2python(RESOURCES / "created-in-pages-bulleted-lists.docx")
227 | assert pars.text == (
228 | "\n\nThis is a document for testing docx2python module.\n\n\n\n--\tWhy "
229 | "did the chicken cross the road?\n\n\t--\tJust because\n\n\t--\tDon't "
230 | "know\n\n\t--\tTo get to the other side\n\n--\tWhat's the meaning of life, "
231 | "universe and everything?\n\n\t--\t42\n\n\t--\t0\n\n\t--\t-1\n\n"
232 | )
233 | pars.close()
234 |
--------------------------------------------------------------------------------
/tests/test_numbering_formats.py:
--------------------------------------------------------------------------------
1 | """Test functions in docx2python.numbering_formats.py
2 |
3 | :author: Shay Hill
4 | :created: 6/26/2019
5 | """
6 |
7 | from random import randint
8 |
9 | import pytest
10 |
11 | from docx2python.numbering_formats import (
12 | bullet,
13 | decimal,
14 | lower_letter,
15 | lower_roman,
16 | upper_letter,
17 | upper_roman,
18 | )
19 | from tests.helpers.utils import ARABIC_2_ROMAN
20 |
21 |
22 | class TestLowerLetter:
23 | """Test numbering_formats.lower_letter"""
24 |
25 | def test_convert_positive_int(self) -> None:
26 | """Convert a positive integer to a string of letters"""
27 | assert lower_letter(1) == "a"
28 | assert lower_letter(26) == "z"
29 | assert lower_letter(27) == "aa"
30 |
31 | def test_zero(self) -> None:
32 | """Raise a value error for < 1"""
33 | with pytest.raises(ValueError) as msg:
34 | _ = lower_letter(0)
35 | assert "0 and <1 are not defined" in str(msg.value)
36 |
37 | def test_neg(self) -> None:
38 | """Raise a value error for < 1"""
39 | with pytest.raises(ValueError) as msg:
40 | _ = lower_letter(-1)
41 | assert "0 and <1 are not defined" in str(msg.value)
42 |
43 |
44 | def test_upper_letter() -> None:
45 | """Same as lower_letter, but upper"""
46 | for _ in range(100):
47 | n = randint(1, 10000)
48 | assert upper_letter(n) == lower_letter(n).upper()
49 |
50 |
51 | class TestLowerRoman:
52 | """Test numbering_formats.lower_roman"""
53 |
54 | def test_convert_positive_int(self) -> None:
55 | """Convert a positive integer to a string of letters"""
56 | for arabic, roman in ARABIC_2_ROMAN.items():
57 | assert lower_roman(arabic) == roman
58 |
59 | def test_zero(self) -> None:
60 | """Raise a value error for < 1"""
61 | with pytest.raises(ValueError) as msg:
62 | _ = lower_roman(0)
63 | assert "Roman" in str(msg.value)
64 |
65 | def test_neg(self) -> None:
66 | """Raise a value error for < 1"""
67 | with pytest.raises(ValueError) as msg:
68 | _ = lower_roman(-1)
69 | assert "Roman" in str(msg.value)
70 |
71 |
72 | def test_upper_roman() -> None:
73 | """Same as lower_roman, but upper"""
74 | for _ in range(100):
75 | n = randint(1, 10000)
76 | assert upper_roman(n) == lower_roman(n).upper()
77 |
78 |
79 | def test_decimal() -> None:
80 | """Return string representation of input"""
81 | for i in range(10):
82 | assert decimal(i) == str(i)
83 |
84 |
85 | def test_bullet() -> None:
86 | """Return same string for every input."""
87 | for i in range(10):
88 | assert bullet(i) == bullet(i * 10)
89 |
--------------------------------------------------------------------------------
/tests/test_par_styles.py:
--------------------------------------------------------------------------------
1 | """Par styles converted to flags
2 |
3 | :author: Shay Hill
4 | :created: 3/18/2021
5 |
6 | """
7 |
8 | from docx2python.iterators import iter_at_depth
9 | from docx2python.main import docx2python
10 | from tests.conftest import RESOURCES
11 |
12 |
13 | class TestParStyles:
14 | def test_par_styles(self) -> None:
15 | """
16 | If do_html, paragraphs style is the first element of every paragraph
17 |
18 | If no paragraph style, empty string is first element of evert paragraph
19 |
20 | :return:
21 | """
22 | with docx2python(RESOURCES / "example.docx") as extraction:
23 | document_pars = extraction.document_pars
24 | styled = [(p.style, p.run_strings) for p in iter_at_depth(document_pars, 4)]
25 | styled = [x for x in styled if x[1]]
26 | expect = [
27 | (
28 | "Header",
29 | [
30 | "Header text",
31 | "----Image alt text---->A close up of a logo\n\n"
32 | + "Description automatically generated<",
33 | "----media/image1.png----",
34 | ],
35 | ),
36 | ("ListParagraph", ["I)\t", "expect I"]),
37 | ("ListParagraph", ["\tA)\t", "expect A"]),
38 | ("ListParagraph", ["\tB)\t", "expect B"]),
39 | ("ListParagraph", ["\t\t1)\t", "expect 1"]),
40 | ("ListParagraph", ["\t\t\ta)\t", "expect a"]),
41 | ("ListParagraph", ["\t\t\tb)\t", "expect b"]),
42 | ("ListParagraph", ["\t\t\t\t1)\t", "expect 1"]),
43 | ("ListParagraph", ["\t\t\t\t\ta)\t", "expect a"]),
44 | ("ListParagraph", ["\t\t\t\t\t\ti)\t", "expect i"]),
45 | ("ListParagraph", ["\t\t\t\t\t\tii)\t", "expect ii"]),
46 | ("ListParagraph", ["II)\t", "This should be II"]),
47 | ("ListParagraph", ["\tA)\t", "This should be A), not C)"]),
48 | ("ListParagraph", ["--\t", "bullet no indent"]),
49 | ("ListParagraph", ["\t--\t", "bullet indent 1"]),
50 | ("ListParagraph", ["\t\t--\t", "bullet indent 2"]),
51 | ("", ["Bold"]),
52 | ("", ["Italics"]),
53 | ("", ["Underlined"]),
54 | ("", ["Large Font"]),
55 | ("", ["Colored"]),
56 | ("", ["Large Colored"]),
57 | ("", ["Large Bold"]),
58 | ("", ["Large Bold Italics Underlined"]),
59 | ("", ["Nested"]),
60 | ("", ["Table"]),
61 | ("", ["A"]),
62 | ("", ["B"]),
63 | ("", ["Tab", "\t", "delimited", "\t", "text"]),
64 | ("", ["10 < 20 and 20 > 10"]),
65 | ("", ["Text outside table"]),
66 | ("", ["Reference footnote 1", "----footnote1----"]),
67 | ("", ["Reference footnote 2", "----footnote2----"]),
68 | ("", ["Reference endnote 1", "----endnote1----"]),
69 | ("", ["Reference endnote 2", "----endnote2----"]),
70 | ("Heading1", ["Heading 1"]),
71 | ("Heading2", ["Heading 2"]),
72 | (
73 | "",
74 | [
75 | "----Image alt text---->A jellyfish in water\n\n"
76 | + "Description automatically generated<",
77 | "----media/image2.jpg----",
78 | ],
79 | ),
80 | (
81 | "Footer",
82 | [
83 | "Footer text",
84 | "----Image alt text---->A close up of a logo\n\n"
85 | + "Description automatically generated<",
86 | "----media/image1.png----",
87 | ],
88 | ),
89 | ("FootnoteText", ["footnote1)\t", " First footnote"]),
90 | (
91 | "FootnoteText",
92 | [
93 | "footnote2)\t",
94 | " Second footnote",
95 | "----Image alt text---->A close up of a logo\n\n"
96 | + "Description automatically generated<",
97 | "----media/image1.png----",
98 | ],
99 | ),
100 | ("EndnoteText", ["endnote1)\t", " First endnote"]),
101 | (
102 | "EndnoteText",
103 | [
104 | "endnote2)\t",
105 | " Second endnote",
106 | "----Image alt text---->A close up of a logo\n\n"
107 | + "Description automatically generated<",
108 | "----media/image1.png----",
109 | ],
110 | ),
111 | ]
112 | assert styled == expect
113 |
--------------------------------------------------------------------------------
/tests/test_pict.py:
--------------------------------------------------------------------------------
1 | """Test functionality with pict elements.
2 |
3 | :author: Shay Hill
4 | :created: 1/29/2020
5 |
6 | Such file was sent to me by stefan-hock20 on github. Images are referenced in
7 | document.html as
8 |
9 | ```
10 |
11 |
13 |
14 |
15 | ```
16 |
17 | docx2text 1.19 would get the image, but not mark the image location in the output text.
18 | """
19 |
20 | from docx2python.main import docx2python
21 | from tests.conftest import RESOURCES
22 |
23 |
24 | class TestPictElement:
25 | def test_extraction(self) -> None:
26 | """Image placeholder inserted into extracted text."""
27 | extraction = docx2python(RESOURCES / "has_pict.docx")
28 | assert "image1.png" in extraction.images
29 | assert "----media/image1.png----" in extraction.text
30 | extraction.close()
31 |
32 |
33 | class TestPictWithAltText:
34 | def test_extraction(self) -> None:
35 | """Image placeholder inserted into extracted text."""
36 | extraction = docx2python(RESOURCES / "pic_alt_text.docx")
37 | text = extraction.text
38 | assert "Alt description" in text
39 | extraction.close()
40 |
--------------------------------------------------------------------------------
/tests/test_run_styles.py:
--------------------------------------------------------------------------------
1 | """Run styles converted to html
2 |
3 | :author: Shay Hill
4 | :created: 3/18/2021
5 |
6 | 16 point
7 | Red
8 |
9 | Courier new
10 | Italic
11 | Bold
12 | Underline
13 | Strikethrough
14 | Double Strikethrough
15 | Superscript
16 | Subscript
17 | Small Caps
18 | All Caps
19 | Highlighted yellow
20 | Highlighted green
21 |
22 | italic
23 | bold
24 | underline
25 | strike
26 | double strike
27 | superscript
28 | subscript
29 | small caps
30 | all caps
31 | highlighted yellow
32 | highlighted green
33 | """
34 |
35 | from docx2python.main import docx2python
36 | from tests.conftest import RESOURCES
37 |
38 |
39 | class TestParStyles:
40 | def test_par_styles(self) -> None:
41 | """
42 | If do_html, paragraphs style is the first element of every run
43 |
44 | :return:
45 | """
46 | content = docx2python(RESOURCES / "run_styles.docx", html=True)
47 | assert content.document_runs == [
48 | [
49 | [
50 | [
51 | ["Normal"],
52 | ['16 point'],
53 | ['Red'],
54 | ["Courier new"],
55 | ["Italic"],
56 | ["Bold"],
57 | ["Underline"],
58 | ["Strikethrough"],
59 | ["Double Strikethough"],
60 | ["Superscript"],
61 | ["Subscript"],
62 | ['Small Caps'],
63 | ['All Caps'],
64 | [
65 | ''
66 | + "Highlighted yellow"
67 | ],
68 | [
69 | ''
70 | + "Highlighted green"
71 | ],
72 | ["Consecutive"],
73 | ["Bold"],
74 | ["Paragraphs"],
75 | [
76 | 'Subscript ',
77 | ''
78 | + "Small Caps ",
79 | ''
80 | + "All Caps ",
81 | ''
82 | + "Highlighted yellow ",
83 | ''
84 | + "Highlighted green",
85 | ],
86 | [],
87 | [],
88 | ]
89 | ]
90 | ]
91 | ]
92 | content.close()
93 |
--------------------------------------------------------------------------------
/tests/test_slanted_quotes.py:
--------------------------------------------------------------------------------
1 | """Test that Word's tilted quotes and double quotes extract Docx2Python."""
2 |
3 | from docx2python.main import docx2python
4 | from tests.conftest import RESOURCES
5 |
6 |
7 | class TestTiltedQuotes:
8 | """Confirming this works with v1.25"""
9 |
10 | def test_exact_representation(self) -> None:
11 | """Most characters are represented exactly"""
12 | with docx2python(RESOURCES / "slanted_quotes.docx") as pars:
13 | assert pars.text == "“double quote”\n\n‘single quote’\n\nApostrophe’s"
14 |
--------------------------------------------------------------------------------
/tests/test_soft_line_breaks.py:
--------------------------------------------------------------------------------
1 | """Start a new paragraph at a soft line break ````
2 |
3 | :author: Shay Hill
4 | :created: 7/7/2021
5 |
6 | Docx2Python previously ignored elements:
7 |
8 | ```
9 | pars = docx2python('soft_line_breaks.docx')
10 | [[[[['Line1Line2Line3'], ['Line4'], []]], [[[]]]], [[[[]]]]]
11 | ```
12 | """
13 |
14 | from docx2python import docx2python
15 | from docx2python.iterators import iter_paragraphs
16 | from tests.conftest import RESOURCES
17 |
18 |
19 | class TestSoftLineBreaks:
20 | def test_separate_pars(self):
21 | """
22 | Start a new paragraph when a element is found.
23 | """
24 | with docx2python(RESOURCES / "soft_line_breaks.docx") as content:
25 | body = content.body
26 | pars = [x for x in iter_paragraphs(body) if x]
27 | assert pars == ["Line1\nLine2\nLine3", "Line4"]
28 |
--------------------------------------------------------------------------------
/tests/test_strict.py:
--------------------------------------------------------------------------------
1 | """A simple test for docx files saved with the strict menu option.
2 |
3 | :author: Shay Hill
4 | :created: 2024-07-02
5 | """
6 |
7 | from docx2python.main import docx2python
8 | from tests.conftest import RESOURCES
9 |
10 |
11 | class TestParagraphsOnly:
12 | """Confirming this works with v1.25"""
13 |
14 | def test_paragraphs_only(self) -> None:
15 | """Run without issue"""
16 | pars = docx2python(RESOURCES / "strict.docx")
17 | assert pars.document == [
18 | [[["--\tBullet1", "--\tBullet2", "1)\tNumber1", "2)\tNumber2"]]],
19 | [[["Cellaa"], ["Cellab"]], [["Cellba"], ["Cellbb"]]],
20 | [[[""]]],
21 | ]
22 |
--------------------------------------------------------------------------------
/tests/test_symbols.py:
--------------------------------------------------------------------------------
1 | """Test symbol extraction.
2 |
3 | :author: Shay Hill
4 | :created: 11/2/2021
5 |
6 | Symbols are captured in the docx content files as ```` elements.
7 |
8 | ```
9 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
17 |
18 | ```
19 | """
20 |
21 | from docx2python.main import docx2python
22 | from tests.conftest import RESOURCES
23 |
24 |
25 | def test_symbols() -> None:
26 | """Export symbols as span elements."""
27 | with docx2python(RESOURCES / "symbols.docx") as pars:
28 | assert pars.text == (
29 | "h"
30 | "≠"
31 | "ð"
32 | "∞×÷≥≤±™®©¥£€µαβπΩ∑"
33 | "J"
34 | "K"
35 | "„"
36 | "æ"
37 | "Ý"
38 | )
39 |
40 |
41 | def test_symbols_with_html_true() -> None:
42 | """Export symbols as span elements."""
43 | with docx2python(RESOURCES / "symbols.docx", html=True) as pars:
44 | assert pars.text == (
45 | "h"
46 | "≠"
47 | "ð"
48 | "∞×÷≥≤±™®©¥£€µαβπΩ∑"
49 | "J"
50 | "K"
51 | "„"
52 | "æ"
53 | "Ý"
54 | )
55 |
--------------------------------------------------------------------------------
/tests/test_tables_to_markdown.py:
--------------------------------------------------------------------------------
1 | """Test converting tables to markdown.
2 |
3 | This is more of an example that an actual test, because I've had multiple requests
4 | for tables as markdown. The new features in docx2python v3 make this straightforward.
5 |
6 | :author: Shay Hill
7 | :created: 2024-07-14
8 | """
9 |
10 | from __future__ import annotations
11 |
12 | from conftest import RESOURCES
13 |
14 | from docx2python import docx2python
15 | from docx2python.depth_collector import Par
16 | from docx2python.iterators import is_tbl, iter_at_depth, iter_tables
17 |
18 |
19 | def _print_tc(cell: list[Par]) -> str:
20 | """Print a table cell as a string on one line."""
21 | ps = ["".join(p.run_strings).replace("\n", " ") for p in cell]
22 | return "\n\n".join(ps)
23 |
24 |
25 | def _join_and_enclose_with_pipes(strings: list[str]) -> str:
26 | """Join strings with pipes and enclose with pipes."""
27 | return "|" + "|".join(strings) + "|"
28 |
29 |
30 | def _print_text(tbl: list[list[list[Par]]]) -> str:
31 | """Text in this list [[[Par]]] is not a table. It's just text."""
32 | all_cells = iter_at_depth(tbl, 2)
33 | return "\n\n".join(_print_tc(tc) for tc in all_cells)
34 |
35 |
36 | def _print_tbl(tbl: list[list[list[Par]]]) -> str:
37 | """Text in this list [[[Par]]] is a table."""
38 | rows_as_string_lists = [[_print_tc(tc) for tc in tr] for tr in tbl]
39 | rows_as_string_lists.insert(1, ["---"] * len(rows_as_string_lists[0]))
40 | rows_as_strings = [
41 | _join_and_enclose_with_pipes(row) for row in rows_as_string_lists
42 | ]
43 | return "\n".join(rows_as_strings)
44 |
45 |
46 | EXPECT = """This document has paragraphs.
47 |
48 | |This|Document|
49 | |---|---|
50 | |Also|Has|
51 | |Tables||
52 |
53 | There are paragraphs between tables. These are used to check the .lineage attribute of Par instances.
54 |
55 | Here is another paragraph between the first and second tables.
56 |
57 | |One More Table|
58 | |---|
59 | |One|
60 | |More|
61 | |Table|
62 |
63 | """
64 |
65 |
66 | def test_tables_to_markdown() -> None:
67 | with docx2python(RESOURCES / "paragraphs_and_tables.docx") as extraction:
68 | tables = extraction.document_pars
69 |
70 | as_text: list[str] = []
71 |
72 | for possible_table in iter_tables(tables):
73 | if is_tbl(possible_table):
74 | as_text.append(_print_tbl(possible_table))
75 | else:
76 | as_text.append(_print_text(possible_table))
77 |
78 | assert "\n\n".join(as_text) == EXPECT
79 |
--------------------------------------------------------------------------------
/tests/test_text_runs.py:
--------------------------------------------------------------------------------
1 | """Test functions in docx2python.text_runs.py
2 |
3 | :author: Shay Hill
4 | :created: 7/4/2019
5 | """
6 |
7 | from lxml import etree
8 |
9 | from docx2python.attribute_register import XML2HTML_FORMATTER
10 | from docx2python.text_runs import gather_Pr, get_run_formatting, html_close, html_open
11 | from tests.helpers.utils import valid_xml
12 |
13 | ONE_TEXT_RUN = valid_xml(
14 | ''
15 | + ""
16 | + ''
17 | + ""
18 | + ""
19 | + ""
20 | + ''
21 | + ''
22 | + ''
23 | + ''
24 | + ""
25 | + "text styled with rPr"
26 | + ""
27 | + ""
28 | )
29 |
30 | NO_STYLE_RUN = valid_xml(
31 | '' + "no styles applies" + "" + ""
32 | )
33 |
34 |
35 | class TestGatherRpr:
36 | """Test text_runs.gather_rPr"""
37 |
38 | def test_get_styles(self):
39 | """Map styles to values."""
40 | document = etree.fromstring(ONE_TEXT_RUN)
41 | assert gather_Pr(document[0][0][0]) == {
42 | "rFonts": None,
43 | "b": None,
44 | "u": "single",
45 | "i": None,
46 | "sz": "32",
47 | "color": "red",
48 | "szCs": "32",
49 | }
50 |
51 | def test_no_styles(self):
52 | """Return empty dict when no rPr for text run."""
53 | document = etree.fromstring(NO_STYLE_RUN)
54 | assert gather_Pr(document[0][0][0]) == {}
55 |
56 |
57 | class TestGetRunStyle:
58 | """Test text_runs.get_run_style"""
59 |
60 | def test_font_and_others(self) -> None:
61 | """Return font first, then other styles."""
62 | document = etree.fromstring(ONE_TEXT_RUN)
63 | assert get_run_formatting(document[0][0][0], XML2HTML_FORMATTER) == [
64 | 'span style="color:red;font-size:32pt"',
65 | "b",
66 | "i",
67 | "u",
68 | ]
69 |
70 |
71 | class TestStyleStrings:
72 | """Test text_runs.style_open and text_runs.style_close"""
73 |
74 | def test_style_open(self) -> None:
75 | """Produce valid html for all defined styles."""
76 | style = ['span style="color:red"', "b", "i", "u"]
77 | assert html_open(style) == ''
78 |
79 | def test_style_close(self) -> None:
80 | """Produce valid html for all defined styles."""
81 | style = ['span style="color:red"', "b", "i", "u"]
82 | assert html_close(style) == ""
83 |
--------------------------------------------------------------------------------
/tests/test_toc_support.py:
--------------------------------------------------------------------------------
1 | """Testing Table of Contents support as requested by user leboni
2 |
3 | :author: Shay Hill
4 | :created: 8/19/2020
5 |
6 | User leboni forwarded a docx file, `zen_of_python.docx` with Table of Contents.
7 | Addressing issue
8 |
9 | `KeyError: '{http://schemas.openxmlformats.org/officeDocument/2006/relationships}id'`
10 |
11 | When attempting to extract content from such documents.
12 |
13 | Two types of links in docx files. Internal links look like actual hyperlinks without
14 | an href.
15 |
16 |
17 |
18 |
19 |
20 |
21 |
22 | Beautiful is better than ugly.
23 |
24 |
25 | """
26 |
27 | from paragraphs import par
28 |
29 | from docx2python.main import docx2python
30 | from tests.conftest import RESOURCES
31 |
32 |
33 | class TestTocText:
34 | def test_get_toc_text(self) -> None:
35 | """Extract header text from table-of-contents header."""
36 | extraction = docx2python(RESOURCES / "zen_of_python.docx")
37 | assert extraction.document_runs == [
38 | [
39 | [[["Contents"], ["\t", "Beautiful is better than ugly.\t1"], []]],
40 | [
41 | [
42 | [],
43 | [],
44 | ["Beautiful is better than ugly."],
45 | ["Explicit is better than implicit."],
46 | ["Simple is better than complex."],
47 | ["Complex is better than complicated."],
48 | ["Flat is better than nested."],
49 | ["Sparse is better than dense."],
50 | ["Readability counts."],
51 | ["Special cases aren't special enough to break the rules."],
52 | ["Although practicality beats purity."],
53 | ["Errors should never pass silently."],
54 | ["Unless explicitly silenced."],
55 | ["In the face of ambiguity, refuse the temptation to guess."],
56 | [
57 | par(
58 | """There should be one-- and preferably only one
59 | --obvious way to do it."""
60 | )
61 | ],
62 | [
63 | par(
64 | """Although that way may not be obvious at first
65 | unless you're Dutch."""
66 | )
67 | ],
68 | ["Now is better than never."],
69 | ["Although never is often better than *right* now."],
70 | ["If the implementation is hard to explain, it's a bad idea."],
71 | [
72 | par(
73 | """If the implementation is easy to explain, it may
74 | be a good idea."""
75 | )
76 | ],
77 | [
78 | par(
79 | """Namespaces are one honking great idea -- let's do
80 | more of those!"""
81 | )
82 | ],
83 | ]
84 | ],
85 | ]
86 | ]
87 | extraction.close()
88 |
--------------------------------------------------------------------------------
/tests/test_utilities.py:
--------------------------------------------------------------------------------
1 | """DocxReader object is able to open a docx file, search and replace text, then save.
2 |
3 | :author: Shay Hill
4 | :created: 2021-12-20
5 | """
6 |
7 | import os
8 | import tempfile
9 |
10 | from docx2python.main import docx2python
11 | from docx2python.utilities import get_headings, get_links, replace_docx_text
12 | from tests.conftest import RESOURCES
13 |
14 |
15 | class TestSearchReplace:
16 | def test_search_and_replace(self) -> None:
17 | """Apples -> Pears, Pears -> Apples
18 |
19 | Ignore html differences when html is False"""
20 |
21 | # assert test file is in default state
22 | html = False
23 | input_filename = RESOURCES / "apples_and_pears.docx"
24 | expect = (
25 | "Apples and Pears\n\nPears and Apples\n\n"
26 | "Apples and Pears\n\nPears and Apples"
27 | )
28 | with docx2python(input_filename, html=html) as input_doc:
29 | result = input_doc.text
30 | assert result == expect
31 |
32 | # attempt a search and replace
33 | with tempfile.TemporaryDirectory() as temp_dir:
34 | output_filename = os.path.join(temp_dir, "pears_and_apples.docx")
35 | replace_docx_text(
36 | input_filename,
37 | output_filename,
38 | ("Apples", "Bananas"),
39 | ("Pears", "Apples"),
40 | ("Bananas", "Pears"),
41 | html=html,
42 | )
43 | expect = (
44 | "Pears and Apples\n\nApples and Pears\n\n"
45 | "Pears and Apples\n\nApples and Pears"
46 | )
47 | with docx2python(output_filename, html=html) as output_doc:
48 | result = output_doc.text
49 |
50 | assert result == expect
51 |
52 | def test_ampersand(self) -> None:
53 | """Apples -> Pears, Pears -> Apples
54 |
55 | Replace text with an ampersand"""
56 | html = False
57 | input_filename = RESOURCES / "apples_and_pears.docx"
58 |
59 | with tempfile.TemporaryDirectory() as temp_dir:
60 | output_filename = os.path.join(temp_dir, "pears_and_apples.docx")
61 | replace_docx_text(
62 | input_filename,
63 | output_filename,
64 | ("Apples", "Apples & Pears <>"),
65 | html=html,
66 | )
67 | with docx2python(output_filename, html=html) as output_doc:
68 | assert output_doc.text == (
69 | "Apples & Pears <> and Pears\n\nPears and Apples & Pears <>\n\n"
70 | "Apples & Pears <> and Pears\n\nPears and Apples & Pears <>"
71 | )
72 |
73 | def test_search_and_replace_html(self) -> None:
74 | """Apples -> Pears, Pears -> Apples
75 |
76 | Exchange strings when formatting is consistent across the string. Leave
77 | alone otherwise.
78 | """
79 | html = True
80 | input_filename = RESOURCES / "apples_and_pears.docx"
81 |
82 | with tempfile.TemporaryDirectory() as temp_dir:
83 | output_filename = os.path.join(temp_dir, "pears_and_apples.docx")
84 | replace_docx_text(
85 | input_filename,
86 | output_filename,
87 | ("Apples", "Bananas"),
88 | ("Pears", "Apples"),
89 | ("Bananas", "Pears"),
90 | html=html,
91 | )
92 | with docx2python(output_filename, html=html) as output_doc:
93 | assert output_doc.text == (
94 | "Pears and Apples\n\n"
95 | "Apples and Pears\n\n"
96 | 'Pears and Apples\n\n'
97 | "Pears and Pears"
98 | )
99 |
100 | def test_search_and_replace_with_linebreaks(self) -> None:
101 | """Apples -> Pears, Pears -> Apples
102 |
103 | Exchange strings when replacement has linebreaks.
104 | """
105 | html = True
106 | input_filename = RESOURCES / "apples_and_pears.docx"
107 | with tempfile.TemporaryDirectory() as temp_dir:
108 | output_filename = os.path.join(temp_dir, "pears_and_apples.docx")
109 | replace_docx_text(
110 | input_filename,
111 | output_filename,
112 | ("Apples", "Bananas"),
113 | ("Pears", "Apples\nPears\nGrapes"),
114 | ("Bananas", "Pears"),
115 | html=html,
116 | )
117 | with docx2python(output_filename, html=html) as output_doc:
118 | assert output_doc.text == (
119 | "Pears and Apples\nPears\nGrapes\n\n"
120 | "Apples\nPears\nGrapes and Pears\n\n"
121 | 'Pears and '
122 | "Apples\nPears\nGrapes\n\n"
123 | "Pears and Pears"
124 | )
125 |
126 |
127 | def test_get_links() -> None:
128 | """Return links as tuples"""
129 | assert [x for x in get_links(RESOURCES / "merged_links.docx")] == [
130 | ("https://www.shayallenhill.com", "hy"),
131 | ("https://www.shayallenhill.com", "per"),
132 | ("https://www.shayallenhill.com", "link"),
133 | ("https://www.shayallenhill.com", "hyperlink"),
134 | ]
135 |
136 |
137 | def test_get_headings() -> None:
138 | """Return all headings (paragraphs with heading style) in document"""
139 | assert [x for x in get_headings(RESOURCES / "example.docx")] == [
140 | ["", "Heading 1", ""],
141 | ["", "Heading 2", ""],
142 | ]
143 |
--------------------------------------------------------------------------------
|