raw-docx 0.9.1__py3-none-any.whl → 0.10.0__py3-none-any.whl

raw_docx/__info__.py

@@ -1 +1 @@
-__package_version__ = "0.9.1"
+__package_version__ = "0.10.0"

raw_docx/docx/docx_paragraph.py

@@ -1,51 +1,193 @@
+import re
 from docx.text.paragraph import Paragraph
 from docx.styles.style import ParagraphStyle
 from docx.text.run import Run
 from simple_error_log import Errors
+from simple_error_log.error_location import KlassMethodLocation
 from raw_docx.raw_run import RawRun
+from raw_docx.raw_simple_field import RawSimpleField
+from raw_docx.raw_bookmark_start import RawBookmarkStart
+from raw_docx.raw_bookmark_end import RawBookmarkEnd
+from docx.oxml.text.run import CT_R
+from lxml import etree
+
+
+BOOKMARK_START = (
+    "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}bookmarkStart"
+)
+BOOKMARK_END = (
+    "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}bookmarkEnd"
+)
+FIELD_SIMPLE = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}fldSimple"
+FIELD_CHAR = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}fldChar"
+INSTRUCTION_TEXT = (
+    "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}instrText"
+)
+
+PARA_PROPERTIES = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}pPr"
+HYPERLINK = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}hyperlink"
+PROOF_ERROR = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}proofErr"
+
+ELEMENT_IGNORE_TAGS = [PARA_PROPERTIES, HYPERLINK, PROOF_ERROR]
+SIMPLE_FIELD_IGNORE_TAGS = [BOOKMARK_START, BOOKMARK_END]
+
+ID_ATTRIBUTE = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}id"
+NAME_ATTRIBUTE = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}name"
+FIELD_CHAR_TYPE_ATTRIBUTE = (
+    "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}fldCharType"
+)
+INSTR_ATTRIBUTE = "{http://schemas.openxmlformats.org/wordprocessingml/2006/main}instr"
+
+MODULE = "raw_docx.docx.docx_paragraph"
 
 
 def install():
-    setattr(Paragraph, "extract_runs", extract_runs)
-
-
-def extract_runs(paragraph: Paragraph, errors: Errors) -> list[RawRun]:
-    if paragraph.text.startswith(
-        "This template is intended for interventional clinical trials.  The template is suitable"
-    ):
-        errors.info(f"Paragraph style {paragraph.style.name}")
-    data = [
-        {
-            "text": run.text,
-            "color": _get_run_color(paragraph.style, run, errors),
-            "highlight": _get_highlight_color(run, errors),
-            "keep": True,
-            # "style": run.style.name if run.style else paragraph.style.name
-            "style": paragraph.style.name,
-        }
-        for run in paragraph.runs
-    ]
-    data = _tidy_runs_color(data, errors)
-    return [RawRun(x["text"], x["color"], x["highlight"], x["style"]) for x in data]
+    setattr(Paragraph, "extract_content", extract_content)
+
+
+def extract_content(
+    paragraph: Paragraph, errors: Errors
+) -> list[RawRun | RawBookmarkStart | RawBookmarkEnd | RawSimpleField]:
+    return process_element(paragraph._element, paragraph, errors)
+
+
+def process_element(
+    element: etree._Element | CT_R, parent: Paragraph, errors: Errors
+) -> list[RawRun | RawBookmarkStart | RawBookmarkEnd | RawSimpleField]:
+    data = []
+    bookmark = None
+    bookmark_id = None
+    for child in element:
+        # print(
+        #     f"XML: {child.xml if isinstance(child, CT_R) else etree.tostring(child, encoding='unicode', pretty_print=True)}, type{type(child)}"
+        # )
+        if isinstance(child, CT_R):
+            run = build_run(child, parent, errors)
+            data.append(run)
+        elif child.tag == BOOKMARK_START:
+            if bookmark:
+                del data[bookmark]
+            id = child.get(ID_ATTRIBUTE)
+            name = child.get(NAME_ATTRIBUTE)
+            data.append(RawBookmarkStart(id, name))
+            bookmark_id = id
+            bookmark = len(data) - 1
+        elif child.tag == BOOKMARK_END:
+            id = child.get(ID_ATTRIBUTE)
+            if id == bookmark_id:
+                name = child.get(NAME_ATTRIBUTE)
+                data.append(RawBookmarkEnd(id, name))
+                bookmark = None
+                bookmark_id = None
+        elif child.tag == FIELD_SIMPLE:
+            bookmark_id = _extract_instruction_id(child.get(INSTR_ATTRIBUTE))
+            items = process_simple_field(child, parent, errors)
+            data.append(RawSimpleField(bookmark_id, create_runs(items, errors)))
+        elif child.tag in ELEMENT_IGNORE_TAGS:
+            pass
+        else:
+            errors.warning(
+                f"Element other instance/tag detected:: '{child.tag}'",
+                KlassMethodLocation(MODULE, "process_element"),
+            )
+    return create_runs(data, errors)
 
 
-def _tidy_runs_color(data: list[dict], errors: Errors) -> list[dict]:
+def process_simple_field(element, parent: Paragraph, errors: Errors) -> list[RawRun]:
+    data = []
+    for child in element:
+        # print(F"CHILD: {child}, type{type(child)}")
+        if isinstance(child, CT_R):
+            run = build_run(child, parent, errors)
+            data.append(run)
+        elif child.tag in SIMPLE_FIELD_IGNORE_TAGS:
+            pass
+        else:
+            errors.warning(
+                f"Simple field other instance/tag detected: '{child.tag}'",
+                KlassMethodLocation(MODULE, "process_element"),
+            )
+    return data
+
+
+def _extract_instruction_id(text: str) -> str:
+    pattern = r"_TN[A-F0-9]+"
+    match = re.search(pattern, text, re.IGNORECASE)
+    return match.group(0) if match else ""
+
+
+def create_runs(data: list[dict], errors: Errors) -> list[RawRun]:
+    data = _tidy_runs(data, errors)
+    results = []
+    for x in data:
+        if isinstance(x, dict):
+            results.append(
+                RawRun(
+                    x["text"],
+                    x["color"],
+                    x["highlight"],
+                    x["style"],
+                    x["superscript"],
+                    x["subscript"],
+                    x["field_char_type"],
+                    x["instruction"],
+                )
+            )
+        else:
+            results.append(x)
+    return results
+
+
+def build_run(element, paragraph: Paragraph, errors: Errors) -> RawRun:
+    run = Run(element, paragraph)
+    field_char_type = None
+    instruction = None
+    for child in element:
+        if child.tag == FIELD_CHAR:
+            field_char_type = child.get(FIELD_CHAR_TYPE_ATTRIBUTE)
+        elif child.tag == INSTRUCTION_TEXT:
+            instruction = _extract_instruction_id(child.text)
+    return {
+        "text": run.text,
+        "color": _get_run_color(paragraph.style, run, errors),
+        "highlight": _get_highlight_color(run, errors),
+        "keep": True,
+        "style": paragraph.style.name,
+        "subscript": run.font.subscript,
+        "superscript": run.font.superscript,
+        "field_char_type": field_char_type,
+        "instruction": instruction,
+    }
+
+
+def _tidy_runs(data: list, errors: Errors) -> list:
     more = False
+    # print(f"TIDY IN: {data}")
     for index, run in enumerate(data):
-        if (
-            index > 0
-            and run["color"] == data[index - 1]["color"]
-            and run["highlight"] == data[index - 1]["highlight"]
-        ):
-            run["text"] = data[index - 1]["text"] + run["text"]
-            data[index - 1]["keep"] = False
-            more = True
-    new_data = [x for x in data if x["keep"]]
+        if index > 0 and isinstance(run, dict) and isinstance(data[index - 1], dict):
+            # print(f"A={run}, B={data[index - 1]}")
+            if _equal_with_ignore(run, data[index - 1], ["text", "keep"]):
+                run["text"] = data[index - 1]["text"] + run["text"]
+                data[index - 1]["keep"] = False
+                more = True
+    new_data = [
+        x
+        for x in data
+        if (isinstance(x, dict) and x["keep"]) or (not isinstance(x, dict))
+    ]
     if more:
-        new_data = _tidy_runs_color(new_data, errors)
+        new_data = _tidy_runs(new_data, errors)
+    # print(f"TIDY OUT: {new_data}")
     return new_data
 
 
+def _equal_with_ignore(a: dict, b: dict, ignore_keys: list) -> bool:
+    # print(f"A={a}, B={b}")
+    return {k: v for k, v in a.items() if k not in ignore_keys} == {
+        k: v for k, v in b.items() if k not in ignore_keys
+    }
+
+
 def _get_run_color(paragraph: Paragraph, run: Run, errors: Errors) -> str | None:
     paragraph_color = _get_font_colour(paragraph, errors)
     font_color = _get_font_colour(run, errors)

raw_docx/raw_bookmark_end.py

@@ -0,0 +1,19 @@
+class RawBookmarkEnd:
+    def __init__(self, id: str, name: str):
+        self.id = id
+        self.name = name
+
+    @property
+    def text(self) -> str:
+        return ""
+
+    def to_html(self) -> str:
+        return ""
+
+    def to_dict(self) -> dict:
+        """Convert the paragraph to a dictionary representation"""
+        return {
+            "type": "bookmark_end",
+            "id": self.id,
+            "name": self.name,
+        }

raw_docx/raw_bookmark_start.py

@@ -0,0 +1,20 @@
+# Note: Bookmark is a target, the desination of any link
+class RawBookmarkStart:
+    def __init__(self, id: str, name: str):
+        self.id = id
+        self.name = name
+
+    @property
+    def text(self) -> str:
+        return ""
+
+    def to_html(self) -> str:
+        return f'<span id="{self.name}"></span>'
+
+    def to_dict(self) -> dict:
+        """Convert the paragraph to a dictionary representation"""
+        return {
+            "type": "bookmark_start",
+            "id": self.id,
+            "name": self.name,
+        }

raw_docx/raw_document.py

@@ -62,3 +62,7 @@ class RawDocument:
                 for title, section in self._section_title_mapping.items()
             },
         }
+
+    def to_html(self) -> str:
+        sections = [section.to_html() for section in self.sections]
+        return ("").join(sections)

raw_docx/raw_docx.py

@@ -76,7 +76,8 @@ class RawDocx:
                     self._process_table(block_item, target_section)
                 else:
                     self._errors.warning(
-                        "Ignoring element", KlassMethodLocation(self.MODULE, "_process")
+                        f"Ignoring element {block_item}",
+                        KlassMethodLocation(self.MODULE, "_process"),
                     )
                     raise ValueError
         except Exception as e:
@@ -133,17 +134,13 @@ class RawDocx:
                     pass
                 else:
                     self._errors.warning(
-                        f"Ignoring eTree element {self._tree(child)}",
+                        f"Ignoring eTree element '{child.tag}'",
                         KlassMethodLocation(self.MODULE, "_iter_block_items"),
                     )
 
             else:
                 raise ValueError(f"something's not right with a child {type(child)}")
 
-    def _tree(self, node, tab=1):
-        for child in node:
-            self._tree(child, tab + 1)
-
     def _process_table(self, table, target: RawSection | RawTableCell):
         target_table = RawTable()
         target.add(target_table)
@@ -168,7 +165,7 @@ class RawDocx:
                                 pass
                             else:
                                 self._errors.warning(
-                                    f"Ignoring eTree element {block_item.tag}",
+                                    f"Ignoring eTree element '{block_item.tag}'",
                                     KlassMethodLocation(self.MODULE, "_process_table"),
                                 )
                         else:
@@ -176,63 +173,10 @@ class RawDocx:
                                 f"Something's not right with a child {type(block_item)}"
                             )
 
-    # def _process_table(self, table, target: RawSection | RawTableCell):
-    #     target_table = RawTable()
-    #     target.add(target_table)
-    #     for r_index, row in enumerate(table.rows):
-    #         target_row = RawTableRow()
-    #         target_table.add(target_row)
-    #         cells = row.cells
-    #         for c_index, cell in enumerate(cells):
-    #             if cell._tc is not None:
-    #                 x = cell._tc
-    #                 right = x.right
-    #                 left = x.left
-    #                 top = x.top
-    #                 try:
-    #                     # Bottom method seems to have a bug.
-    #                     # See https://github.com/python-openxml/python-docx/issues/1433
-    #                     bottom = x.bottom
-    #                 except Exception as e:
-    #                     self._errors.exception(
-    #                         f"Row span exception! {x.xml}",
-    #                         e,
-    #                         KlassMethodLocation(self.MODULE, "_process_table"),
-    #                     )
-    #                     bottom = top + 1
-    #                 h_span = right - left
-    #                 v_span = bottom - top
-    #             else:
-    #                 h_span = 1
-    #                 v_span = 1
-    #             if cell._tc is not None:
-    #                 first = r_index == cell._tc.top and c_index == cell._tc.left
-    #             else:
-    #                 first = r_index == 0 and c_index == 0
-    #             target_cell = RawTableCell(h_span, v_span, first)
-    #             target_row.add(target_cell)
-    #             for block_item in self._iter_block_items(cell):
-    #                 if isinstance(block_item, Paragraph):
-    #                     self._process_cell(block_item, target_cell)
-    #                 elif isinstance(block_item, Table):
-    #                     raise self.LogicError("Table within table detected")
-    #                 elif isinstance(block_item, etree._Element):
-    #                     if block_item.tag == CT_TcPr:
-    #                         pass
-    #                     else:
-    #                         self._errors.warning(
-    #                             f"Ignoring eTree element {block_item.tag}",
-    #                             KlassMethodLocation(self.MODULE, "_process_table"),
-    #                         )
-    #                 else:
-    #                     raise self.LogicError(
-    #                         f"Something's not right with a child {type(block_item)}"
-    #                     )
-
     def _process_cell(self, paragraph, target_cell: RawTableCell):
         if self._is_list(paragraph):
             list_level = self.get_list_level(paragraph)
-            item = RawListItem(paragraph.extract_runs(self._errors), list_level)
+            item = RawListItem(paragraph.extract_content(self._errors), list_level)
             if target_cell.is_in_list():
                 list = target_cell.current_list()
             else:
@@ -240,7 +184,7 @@ class RawDocx:
                 target_cell.add(list)
             list.add(item)
         else:
-            target_paragraph = RawParagraph(paragraph.extract_runs(self._errors))
+            target_paragraph = RawParagraph(paragraph.extract_content(self._errors))
             target_cell.add(target_paragraph)
 
     def _process_paragraph(
@@ -252,7 +196,7 @@ class RawDocx:
             self.target_document.add(target_section)
         elif self._is_list(paragraph):
             list_level = self.get_list_level(paragraph)
-            item = RawListItem(paragraph.extract_runs(self._errors), list_level)
+            item = RawListItem(paragraph.extract_content(self._errors), list_level)
             if target_section.is_in_list():
                 list = target_section.current_list()
             else:
@@ -265,7 +209,8 @@ class RawDocx:
                     target_image = RawImage(image_rels[rId], self._errors)
                     target_section.add(target_image)
         else:
-            target_paragraph = RawParagraph(paragraph.extract_runs(self._errors))
+            # print("===== Raw Para =====")
+            target_paragraph = RawParagraph(paragraph.extract_content(self._errors))
             target_section.add(target_paragraph)
 
     def get_list_level(self, paragraph):

raw_docx/raw_paragraph.py

@@ -1,16 +1,13 @@
 from .raw_run import RawRun
+from .raw_bookmark_start import RawBookmarkStart
+from .raw_bookmark_end import RawBookmarkEnd
 
 
 class RawParagraph:
-    def __init__(self, runs: list[RawRun]):
-        self.runs = runs
+    def __init__(self, items: list[RawRun | RawBookmarkStart | RawBookmarkEnd]):
+        self.items = items
+        self.text = self._item_text()
         self.klasses = []
-        self.text = self._run_text()
-
-    def to_html(self) -> str:
-        klass_list = " ".join(self.klasses)
-        open_tag = f'<p class="{klass_list}">' if self.klasses else "<p>"
-        return f"{open_tag}{self.text}</p>"
 
     def find(self, text: str) -> bool:
         return True if text in self.text else False
@@ -18,6 +15,49 @@ class RawParagraph:
     def find_at_start(self, text: str) -> bool:
         return True if self.text.upper().startswith(text.upper()) else False
 
+    def to_html(self) -> str:
+        klass_list = " ".join(self.klasses)
+        open_tag = f'<p class="{klass_list}">' if self.klasses else "<p>"
+        close_tag = "</p>"
+        body = ""
+        in_anchor = False
+        in_bookmark = False
+        bookmark_id = None
+        for index, item in enumerate(self.items):
+            if isinstance(item, RawRun):
+                if item.field_char_type == "begin":
+                    if next_item := self._next_run_item(index):
+                        if next_item.instruction:
+                            body += f'<a class="raw-docx-cross-ref" href="#{next_item.instruction}">'
+                            in_anchor = True
+                elif item.field_char_type == "separate":
+                    if next_item := self._next_run_item(index):
+                        if next_item.instruction:
+                            body += f'<a class="raw-docx-cross-ref" href="#{next_item.instruction}">'
+                            in_anchor = True
+                        elif in_bookmark:
+                            body += (
+                                f'<span class="raw-docx-bookmark" id="{bookmark_id}">'
+                            )
+                elif in_anchor and item.field_char_type == "end":
+                    body += "</a>"
+                    in_anchor = False
+                elif in_bookmark and item.field_char_type == "end":
+                    body += "</span>"
+                    in_bookmark = False  # Will also be caught by BookmarkEnd
+                    bookmark_id = None
+                else:
+                    body += item.to_html()
+            elif isinstance(item, RawBookmarkStart):
+                in_bookmark = True
+                bookmark_id = item.name
+            elif isinstance(item, RawBookmarkEnd):
+                in_bookmark = False  # Will also be caught by field_char_type = "end"
+                bookmark_id = None
+            else:
+                body += item.to_html()
+        return f"{open_tag}{body}{close_tag}"
+
     def add_class(self, klass) -> None:
         self.klasses.append(klass)
 
@@ -26,7 +66,7 @@ class RawParagraph:
         return {
             "type": "paragraph",
             "text": self.text,
-            "runs": [run.to_dict() for run in self.runs],
+            "items": [item.to_dict() for item in self.items],
             "classes": self.klasses,
         }
 
@@ -34,5 +74,23 @@ class RawParagraph:
         new_str = f'<span class="{klass}">{text}</span>'
         self.text = new_str + self.text[len(text) :]
 
-    def _run_text(self) -> str:
-        return "".join([run.text for run in self.runs])
+    def _next_run_item(self, start: int) -> RawRun | None:
+        for index in range(start + 1, len(self.items)):
+            if isinstance(self.items[index], RawRun):
+                return self.items[index]
+        return None
+
+    def _item_text(self) -> str:
+        text = ""
+        in_separate = False
+        for index, item in enumerate(self.items):
+            if isinstance(item, RawRun):
+                if item.field_char_type == "separate":
+                    in_separate = True
+                elif in_separate and item.field_char_type == "end":
+                    in_separate = False
+                elif not in_separate:
+                    text += item.text
+            else:
+                text += item.text
+        return text

raw_docx/raw_run.py

@@ -1,15 +1,49 @@
 class RawRun:
-    def __init__(self, text: str, color: str | None, highlight: str | None, style: str):
-        self.text = text
+    def __init__(
+        self,
+        text: str,
+        color: str | None,
+        highlight: str | None,
+        style: str,
+        superscript: bool,
+        subscript: bool,
+        field_char_type: str,
+        instruction: str,
+    ):
+        self._text = text
         self.color = color
         self.highlight = highlight
         self.style = style
+        self.subscript = subscript
+        self.superscript = superscript
+        self.field_char_type = field_char_type
+        self.instruction = instruction
+
+    @property
+    def text(self) -> str:
+        return "" if self.subscript or self.superscript else self._text
+
+    def to_html(self) -> str:
+        # Note: no support for colours as yet
+        if self.field_char_type:
+            return ""
+        elif self.subscript:
+            return f"<sub>{self.text}</sub>" if self.text else ""
+        elif self.superscript:
+            return f"<sup>{self.text}</sup>" if self.text else ""
+        else:
+            return f"{self.text}"
 
     def to_dict(self) -> dict:
         """Convert the instace to a dictionary representation"""
         return {
+            "type": "run",
             "text": self.text,
             "color": self.color,
             "highlight": self.highlight,
             "style": self.style,
+            "superscript": self.superscript,
+            "subscript": self.subscript,
+            "field_char_type": self.field_char_type,
+            "instruction": self.instruction,
         }

raw_docx/raw_section.py

@@ -94,6 +94,9 @@ class RawSection:
     def next(self, index: int):
         return self.items[index + 1] if (index + 1) < len(self.items) else None
 
+    def index(self, item: RawParagraph | RawList | RawTable | RawImage) -> int | None:
+        return next((i for i, x in enumerate(self.items) if x is item), None)
+
     def next_paragraph(self, start_index: int) -> RawParagraph:
         for index, item in enumerate(self.items):
             if index >= start_index:

raw_docx/raw_simple_field.py

@@ -0,0 +1,24 @@
+from .raw_run import RawRun
+
+
+class RawSimpleField:
+    def __init__(self, id: str, items: list[RawRun]):
+        self.id = id
+        self.items = items
+        self.text = self._item_text()
+
+    def to_html(self) -> str:
+        start_tag = f'<a class="raw-docx-cross-ref" href="#{self.id}">'
+        end_tag = "</a>"
+        return f"{start_tag}{''.join([item.to_html() for item in self.items])}{end_tag}"
+
+    def to_dict(self) -> dict:
+        return {
+            "type": "simple_field",
+            "id": self.id,
+            "text": self.text,
+            "items": [item.to_dict() for item in self.items],
+        }
+
+    def _item_text(self) -> str:
+        return "".join([x.text for x in self.items])

{raw_docx-0.9.1.dist-info → raw_docx-0.10.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: raw_docx
-Version: 0.9.1
+Version: 0.10.0
 Summary: A package for processing and analyzing raw document formats
 Home-page: https://github.com/daveih/raw_docx
 Author: Dave Iberson-Hurst
@@ -33,9 +33,12 @@ Dynamic: summary
 
 Simple package to build on top of python-docx to assist in the handling of word documents
 
-# Build
+# Build Package
 
-Build as a normal package
+Build steps for deployment to pypi.org
 
+- Run `pytest`, ensure coverage and all tests pass
+- Run `ruff format`
+- Run `ruff check`, ensure no errors
 - Build with `python3 -m build --sdist --wheel`
 - Upload to pypi.org using `twine upload dist/*`

raw_docx-0.10.0.dist-info/RECORD

@@ -0,0 +1,24 @@
+raw_docx/__info__.py,sha256=h9PyxJrMiLzLjjHyl_X5nf8x8m1g2dhpuTyPcSoFF4Y,31
+raw_docx/__init__.py,sha256=FE5cpoCK1EVhpz3LiOOs43l027PcuJN5RljdW0UWON0,591
+raw_docx/raw_bookmark_end.py,sha256=D9SpnM3HKOvICUn7HJEEkph6v782udUQD5e6KceOutM,441
+raw_docx/raw_bookmark_start.py,sha256=_2H3DVaPQtn2Bu8upFd0pfqMtMNOE6LylIkq-6H9EpA,533
+raw_docx/raw_document.py,sha256=Lq28CE3f-S_gfVxMC6FpykTKLr1Tviqyx3WzfHOAOPo,2474
+raw_docx/raw_docx.py,sha256=mXK2YB0JPTkf3GsYMxN4r3CLVEQop399pjSvPD6YGTc,11247
+raw_docx/raw_image.py,sha256=IUUETwW73-guaa_v-cHpfw0_z69u9wfvEk7adm9hHJQ,1506
+raw_docx/raw_list.py,sha256=bhssQX_oVf8uBmUbcrCIzIJ8pCvdEtdHOAQBNH0EEQQ,2282
+raw_docx/raw_list_item.py,sha256=I65FDqU4YE6TJ615qH1GYDcXTPKnlk173xXPr3MCMcQ,599
+raw_docx/raw_paragraph.py,sha256=rXBTeiBg-eIEK0NEFhUbGO2I_N-NsyRX1dGPZoaGYFg,3841
+raw_docx/raw_run.py,sha256=Kl1HmZ5R_z0S9R3u5RC_e6HcfcPYMidzSb9Q6FN1TXI,1492
+raw_docx/raw_section.py,sha256=4WNKveU4wDCCwLrB797woPLBzj2PCnqU3gV0pNRQeG0,4108
+raw_docx/raw_simple_field.py,sha256=jPcZhqzN6F3uCb6eXEWBkKOBBjoxw4so6EX9a00wjo4,711
+raw_docx/raw_table.py,sha256=Sc0vV7g-Gonmo_EbdWyYmQy_rvgf4A-PYLuIrX_FTfc,1622
+raw_docx/raw_table_cell.py,sha256=3gKm3m5JlkFVuEy9EHVhC2viNDUKfggny_bblY1TC48,1967
+raw_docx/raw_table_row.py,sha256=m8SoLyVlKLjd_Vqa_U79A2wi8Wout8spgyusqJm79Kc,1297
+raw_docx/docx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+raw_docx/docx/docx_paragraph.py,sha256=A1bBXWt2qVWAihX1dvYuWXV3QmDSuijWv2Of_qw6IMk,8185
+raw_docx/docx/docx_table.py,sha256=dG8jjkOnxGwN-6KtqdoYq8znO2XLYuIYhjbr4ZjIs2Y,5404
+raw_docx-0.10.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+raw_docx-0.10.0.dist-info/METADATA,sha256=sBCucC0z6oMmrfj7Mxppul2KNbu6Q6tyvFhb8WBIwl4,1367
+raw_docx-0.10.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+raw_docx-0.10.0.dist-info/top_level.txt,sha256=Xl3dspPM9DBVj8clfdkHG7N4nNjNXeUmB4HcXAwOe60,9
+raw_docx-0.10.0.dist-info/RECORD,,

raw_docx-0.9.1.dist-info/RECORD

@@ -1,21 +0,0 @@
-raw_docx/__info__.py,sha256=0zPMqZ5bMSGqKHkuj4WY2o5mQl7U-b-FYZPn4LEUths,30
-raw_docx/__init__.py,sha256=FE5cpoCK1EVhpz3LiOOs43l027PcuJN5RljdW0UWON0,591
-raw_docx/raw_document.py,sha256=hUrnf6QZs9-yysnz1UmYZCYvhqdyPi3v2i-t5mu5KsI,2340
-raw_docx/raw_docx.py,sha256=bp4No6XbnwPoWkNsnutbxARgV5RzgNa7jalr8IMjUbQ,13843
-raw_docx/raw_image.py,sha256=IUUETwW73-guaa_v-cHpfw0_z69u9wfvEk7adm9hHJQ,1506
-raw_docx/raw_list.py,sha256=bhssQX_oVf8uBmUbcrCIzIJ8pCvdEtdHOAQBNH0EEQQ,2282
-raw_docx/raw_list_item.py,sha256=I65FDqU4YE6TJ615qH1GYDcXTPKnlk173xXPr3MCMcQ,599
-raw_docx/raw_paragraph.py,sha256=GDEU89MFVgzD52t0e7Tau8tm6V0uTtaHMawfpU2RbT0,1209
-raw_docx/raw_run.py,sha256=0PJHiZIm1QclZfjdsrPPLSL7_GYoX8jSa6JvcfcOcWc,479
-raw_docx/raw_section.py,sha256=_ONvR5Fyuif4vZs1LnE7Y67pX29JKWM13YB8Wy8di9o,3942
-raw_docx/raw_table.py,sha256=Sc0vV7g-Gonmo_EbdWyYmQy_rvgf4A-PYLuIrX_FTfc,1622
-raw_docx/raw_table_cell.py,sha256=3gKm3m5JlkFVuEy9EHVhC2viNDUKfggny_bblY1TC48,1967
-raw_docx/raw_table_row.py,sha256=m8SoLyVlKLjd_Vqa_U79A2wi8Wout8spgyusqJm79Kc,1297
-raw_docx/docx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-raw_docx/docx/docx_paragraph.py,sha256=DPFzCG26y-6teL3KDnC_Ihmbs48OsHfD4fCD5Tj1O4A,2938
-raw_docx/docx/docx_table.py,sha256=dG8jjkOnxGwN-6KtqdoYq8znO2XLYuIYhjbr4ZjIs2Y,5404
-raw_docx-0.9.1.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-raw_docx-0.9.1.dist-info/METADATA,sha256=Bkl3JymHFUutu7-mx3WQjckO9axotoTqTBg4ATOT5Cw,1237
-raw_docx-0.9.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-raw_docx-0.9.1.dist-info/top_level.txt,sha256=Xl3dspPM9DBVj8clfdkHG7N4nNjNXeUmB4HcXAwOe60,9
-raw_docx-0.9.1.dist-info/RECORD,,