raw-docx 0.5.0__py3-none-any.whl → 0.7.0__py3-none-any.whl

raw_docx/__info__.py

@@ -0,0 +1 @@
+__package_version__ = "0.7.0"

raw_docx/__init__.py

@@ -0,0 +1,25 @@
+from .raw_docx import RawDocx
+from .raw_document import RawDocument
+from .raw_image import RawImage
+from .raw_list_item import RawListItem
+from .raw_list import RawList
+from .raw_paragraph import RawParagraph
+from .raw_run import RawRun
+from .raw_section import RawSection
+from .raw_table_cell import RawTableCell
+from .raw_table_row import RawTableRow
+from .raw_table import RawTable
+
+__all__ = [
+    "RawDocx",
+    "RawDocument",
+    "RawImage",
+    "RawList",
+    "RawListItem",
+    "RawParagraph",
+    "RawRun",
+    "RawSection",
+    "RawTableCell",
+    "RawTableRow",
+    "RawTable",
+]

raw_docx/{docx_paragraph.py → docx/docx_paragraph.py}

@@ -1,31 +1,35 @@
 from docx.text.paragraph import Paragraph
 from docx.styles.style import ParagraphStyle
 from docx.text.run import Run
-from .raw_logger import logger
-from .raw_run import RawRun
+from simple_error_log import Errors
+from raw_docx.raw_run import RawRun
 
 
-def extract_runs(paragraph: Paragraph) -> list[dict]:
+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"
     ):
-        logger.info(f"Paragraph style {paragraph.style.name}")
+        errors.info(f"Paragraph style {paragraph.style.name}")
     data = [
         {
             "text": run.text,
-            "color": _get_run_color(paragraph.style, run),
-            "highlight": _get_highlight_color(run),
+            "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)
+    data = _tidy_runs_color(data, errors)
     return [RawRun(x["text"], x["color"], x["highlight"], x["style"]) for x in data]
 
 
-def _tidy_runs_color(data: list[dict]) -> list[dict]:
+def _tidy_runs_color(data: list[dict], errors: Errors) -> list[dict]:
     more = False
     for index, run in enumerate(data):
         if (
@@ -38,14 +42,14 @@ def _tidy_runs_color(data: list[dict]) -> list[dict]:
             more = True
     new_data = [x for x in data if x["keep"]]
     if more:
-        new_data = _tidy_runs_color(new_data)
+        new_data = _tidy_runs_color(new_data, errors)
     return new_data
 
 
-def _get_run_color(paragraph: Paragraph, run: Run) -> str | None:
-    paragraph_color = _get_font_colour(paragraph)
-    font_color = _get_font_colour(run)
-    style_color = _run_style_color(run)
+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)
+    style_color = _run_style_color(run, errors)
     if font_color:
         result = str(font_color)
     elif style_color:
@@ -55,15 +59,15 @@ def _get_run_color(paragraph: Paragraph, run: Run) -> str | None:
     return result
 
 
-def _get_highlight_color(run: Run) -> str | None:
+def _get_highlight_color(run: Run, errors: Errors) -> str | None:
     try:
         return str(run.font.highlight_color)
     except Exception as e:
-        logger.exception("Failed to get run highlight color", e)
+        errors.exception("Failed to get run highlight color", e)
         return None
 
 
-def _run_style_color(run: Run) -> str | None:
+def _run_style_color(run: Run, errors: Errors) -> str | None:
     try:
         run_color = None
         run_style = run.style
@@ -74,16 +78,13 @@ def _run_style_color(run: Run) -> str | None:
                 run_style = run_style.base_style
         return run_color
     except Exception as e:
-        logger.exception("Failed to get run style color", e)
+        errors.exception("Failed to get run style color", e)
         return None
 
 
-def _get_font_colour(item: Run | ParagraphStyle) -> str | None:
+def _get_font_colour(item: Run | ParagraphStyle, errors: Errors) -> str | None:
     try:
         return item.font.color.rgb
     except Exception as e:
-        logger.exception("Failed to get font color", e)
+        errors.exception("Failed to get font color", e)
         return None
-
-
-setattr(Paragraph, "extract_runs", extract_runs)

raw_docx/raw_docx.py

@@ -3,15 +3,16 @@ import re
 import docx
 import zipfile
 from pathlib import Path
-from .raw_document import RawDocument
-from .raw_section import RawSection
-from .raw_paragraph import RawParagraph
-from .raw_image import RawImage
-from .raw_table import RawTable
-from .raw_table_row import RawTableRow
-from .raw_table_cell import RawTableCell
-from .raw_list import RawList
-from .raw_list_item import RawListItem
+from raw_docx.raw_document import RawDocument
+from raw_docx.raw_section import RawSection
+from raw_docx.raw_paragraph import RawParagraph
+from raw_docx.raw_image import RawImage
+from raw_docx.raw_table import RawTable
+from raw_docx.raw_table_row import RawTableRow
+from raw_docx.raw_table_cell import RawTableCell
+from raw_docx.raw_list import RawList
+from raw_docx.raw_list_item import RawListItem
+from raw_docx.docx.docx_paragraph import install
 from docx import Document as DocXProcessor
 from docx.document import Document
 from docx.oxml.table import CT_Tbl, CT_TcPr
@@ -19,8 +20,7 @@ from docx.oxml.text.paragraph import CT_P
 from docx.table import Table, _Cell
 from docx.text.paragraph import Paragraph
 from lxml import etree
-from .raw_logger import logger
-from .docx_paragraph import extract_runs  # Needed such that method inserted into class
+from simple_error_log import Errors
 
 
 class RawDocx:
@@ -28,12 +28,17 @@ class RawDocx:
         pass
 
     def __init__(self, full_path: str):
+        install()
+        self.errors = Errors()
         path = Path(full_path)
         # path.stem, path.suffix[1:]
         self.full_path = full_path
         self.dir = path.parent
         self.filename = path.name
         self.image_path = os.path.join(self.dir, "images")
+        self.errors.debug(
+            f"RawDocx initialisation: full_path='{self.full_path}', dir='{self.dir}', image_path0'{self.image_path}', filename='{self.filename}"
+        )
         self.image_rels = {}
         self._organise_dir()
         self.source_document = DocXProcessor(self.full_path)
@@ -46,28 +51,26 @@ class RawDocx:
         except FileExistsError:
             pass
         except Exception as e:
-            logger.exception("Failed to create image directory", e)
+            self.errors.exception("Failed to create image directory", e)
 
     def _process(self):
         try:
-            self._extract_images()
+            self._process_images()
             for block_item in self._iter_block_items(self.source_document):
                 target_section = self.target_document.current_section()
                 if isinstance(block_item, Paragraph):
-                    # print(f"PARA BLOCK: {block_item.text}")
                     self._process_paragraph(block_item, target_section, self.image_rels)
                 elif isinstance(block_item, Table):
                     self._process_table(block_item, target_section)
                 else:
-                    logger.warning("Ignoring element")
+                    self.errors.warning("Ignoring element")
                     raise ValueError
         except Exception as e:
-            logger.exception("Exception raised processing document", e)
+            self.errors.exception("Exception raised processing document", e)
 
-    def _extract_images(self):
+    def _process_images(self):
         # Extract images to image dir
         self._extract_images()
-        # Save all 'rId:filenames' as references
         for r in self.source_document.part.rels.values():
             if isinstance(r._target, docx.parts.image.ImagePart):
                 self.image_rels[r.rId] = os.path.join(
@@ -91,9 +94,8 @@ class RawDocx:
 
         for child in parent_elm.iterchildren():
             if isinstance(child, str):
-                logger.warning(f"Ignoring eTree element {child}")
+                self.errors.warning(f"Ignoring eTree element {child}")
             elif isinstance(child, CT_P):
-                # print(f"PARA: {child.text}")
                 yield Paragraph(child, parent)
             elif isinstance(child, CT_Tbl):
                 yield Table(child, parent)
@@ -109,13 +111,12 @@ class RawDocx:
                 ):
                     pass
                 else:
-                    logger.warning(f"Ignoring eTree element {self._tree(child)}")
+                    self.errors.warning(f"Ignoring eTree element {self._tree(child)}")
 
             else:
                 raise ValueError(f"something's not right with a child {type(child)}")
 
     def _tree(self, node, tab=1):
-        # print(f"{'  ' * tab}{node.tag} {node.text}")
         for child in node:
             self._tree(child, tab + 1)
 
@@ -155,7 +156,9 @@ class RawDocx:
                         if block_item.tag == CT_TcPr:
                             pass
                         else:
-                            logger.warning(f"Ignoring eTree element {block_item.tag}")
+                            self.errors.warning(
+                                f"Ignoring eTree element {block_item.tag}"
+                            )
                     else:
                         raise self.LogicError(
                             f"something's not right with a child {type(block_item)}"
@@ -164,15 +167,15 @@ class RawDocx:
     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(), list_level)
+            item = RawListItem(paragraph.extract_runs(self.errors), list_level)
             if target_cell.is_in_list():
                 list = target_cell.current_list()
             else:
-                list = RawList()
+                list = RawList(self.errors)
                 target_cell.add(list)
             list.add(item)
         else:
-            target_paragraph = RawParagraph(paragraph.extract_runs())
+            target_paragraph = RawParagraph(paragraph.extract_runs(self.errors))
             target_cell.add(target_paragraph)
 
     def _process_paragraph(
@@ -183,23 +186,21 @@ class RawDocx:
             target_section = RawSection(paragraph.text, paragraph.text, level)
             self.target_document.add(target_section)
         elif self._is_list(paragraph):
-            # print(f"START LIST: {paragraph.text}")
             list_level = self.get_list_level(paragraph)
-            item = RawListItem(paragraph.extract_runs(), list_level)
+            item = RawListItem(paragraph.extract_runs(self.errors), list_level)
             if target_section.is_in_list():
                 list = target_section.current_list()
             else:
-                list = RawList()
+                list = RawList(self.errors)
                 target_section.add(list)
             list.add(item)
         elif "Graphic" in paragraph._p.xml:
             for rId in image_rels:
                 if rId in paragraph._p.xml:
-                    target_image = RawImage(image_rels[rId])
+                    target_image = RawImage(image_rels[rId], self.errors)
                     target_section.add(target_image)
         else:
-            # print(f"START RUNS: {paragraph.text}")
-            target_paragraph = RawParagraph(paragraph.extract_runs())
+            target_paragraph = RawParagraph(paragraph.extract_runs(self.errors))
             target_section.add(target_paragraph)
 
     def get_list_level(self, paragraph):

raw_docx/raw_image.py

@@ -1,12 +1,13 @@
 import os
 import base64
-from .raw_logger import logger
+from simple_error_log import Errors
 
 
 class RawImage:
     FILE_TYPE_MAP = {".png": "png", ".jpg": "jpg", ".jpeg": "jpg"}
 
-    def __init__(self, filepath: str):
+    def __init__(self, filepath: str, errors: Errors):
+        self.errors = errors
         self.filepath = filepath
 
     def to_html(self):
@@ -21,7 +22,7 @@ class RawImage:
             else:
                 return f"""<p style="color:red">Note: Unable to process embedded image of type '{file_extension}', image ignored.</p>"""
         except Exception as e:
-            logger.exception("Exception converting image", e)
+            self.errors.exception("Exception converting image", e)
             return (
                 """<p style="color:red">Note: Error encountered processing image.</p>"""
             )

raw_docx/raw_list.py

@@ -1,9 +1,10 @@
 from .raw_list_item import RawListItem
-from .raw_logger import logger
+from simple_error_log import Errors
 
 
 class RawList:
-    def __init__(self, level=0):
+    def __init__(self, errors: Errors, level=0):
+        self.errors = errors
         self.items = []  # List to store RawListItems and nested RawLists
         self.level = level
 
@@ -13,15 +14,15 @@ class RawList:
         elif item.level > self.level:
             list = self.items[-1] if self.items else None
             if not isinstance(list, RawList):
-                list = RawList(item.level)
+                list = RawList(self.errors, item.level)
                 self.items.append(list)
             list.add(item)
             if item.level > self.level + 1:
-                logger.warning(
+                self.errors.warning(
                     f"Adding list item '{item}' to item but level jump greater than 1"
                 )
         else:
-            logger.error(
+            self.errors.error(
                 f"Failed to add list item '{item}' to list '{self}', levels are in error"
             )
 

raw_docx/raw_list_item.py

@@ -12,7 +12,8 @@ class RawListItem(RawParagraph):
         return f"{'  ' * self.level}{self.text}"
 
     def to_html(self) -> str:
-        return f"{escape(self.text)}"
+        return f"{self.text}"
+        # return f"{escape(self.text)}"
 
     def to_dict(self) -> dict:
         return {"type": "list_item", "text": self.text, "level": self.level}

raw_docx/raw_paragraph.py

@@ -11,7 +11,7 @@ class RawParagraph:
     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}{escape(self.text)}</p>"
+        return f"{open_tag}{self.text}</p>"
 
     def find(self, text: str) -> bool:
         return True if text in self.text else False
@@ -31,5 +31,9 @@ class RawParagraph:
             "classes": self.klasses,
         }
 
+    def add_span(self, text: str, klass: str) -> None:
+        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])

{raw_docx-0.5.0.dist-info → raw_docx-0.7.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
-Metadata-Version: 2.2
+Metadata-Version: 2.4
 Name: raw_docx
-Version: 0.5.0
+Version: 0.7.0
 Summary: A package for processing and analyzing raw document formats
 Home-page: https://github.com/daveih/raw_docx
 Author: Dave Iberson-Hurst
@@ -18,12 +18,13 @@ Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: python-docx
-Requires-Dist: python-json-logger
+Requires-Dist: simple_error_log
 Dynamic: author
 Dynamic: classifier
 Dynamic: description
 Dynamic: description-content-type
 Dynamic: home-page
+Dynamic: license-file
 Dynamic: requires-dist
 Dynamic: requires-python
 Dynamic: summary

raw_docx-0.7.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+raw_docx/__info__.py,sha256=JyImHLdD9tOVOKODJRy37_fBqVJ9Nup6yLR4gOOCtz8,30
+raw_docx/__init__.py,sha256=FE5cpoCK1EVhpz3LiOOs43l027PcuJN5RljdW0UWON0,591
+raw_docx/raw_document.py,sha256=VLx0-Z9jGwdYHMU227AKaT8UDRY_OHD7b2BRuw71x6M,2340
+raw_docx/raw_docx.py,sha256=VhmwkP1kO5Bjr1WnfCyJE6JL728ZEHvStlQ78VuFFxQ,10379
+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=4Mn3rmnpXppJGAxk-9StLD60wszk5igg-TIbBz8sKW4,623
+raw_docx/raw_paragraph.py,sha256=edFNwudoBWNWdj5b3ac0e6LFrFuZjU_ize70ToUGQN8,1233
+raw_docx/raw_run.py,sha256=0PJHiZIm1QclZfjdsrPPLSL7_GYoX8jSa6JvcfcOcWc,479
+raw_docx/raw_section.py,sha256=_ONvR5Fyuif4vZs1LnE7Y67pX29JKWM13YB8Wy8di9o,3942
+raw_docx/raw_table.py,sha256=qm-Ap1AOHRuOxiUgHsI6uV4GeCNEJrE0Z3TZ8rXbffg,1579
+raw_docx/raw_table_cell.py,sha256=pXe7FCfEmbqdktBGfkDrvMsbEie8FaGNQbRl_ooms0Q,1887
+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-0.7.0.dist-info/licenses/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
+raw_docx-0.7.0.dist-info/METADATA,sha256=aNG1bN6ZnwCWqRv0y2x0-vNhmolaJb8qm04N-gtVvQI,1224
+raw_docx-0.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+raw_docx-0.7.0.dist-info/top_level.txt,sha256=Xl3dspPM9DBVj8clfdkHG7N4nNjNXeUmB4HcXAwOe60,9
+raw_docx-0.7.0.dist-info/RECORD,,

{raw_docx-0.5.0.dist-info → raw_docx-0.7.0.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.8.2)
+Generator: setuptools (80.9.0)
 Root-Is-Purelib: true
 Tag: py3-none-any
 

raw_docx/__version__.py

@@ -1 +0,0 @@
-__package_version__ = "0.5.0"

raw_docx/raw_logger.py

@@ -1,67 +0,0 @@
-import sys
-import logging
-from pathlib import Path
-from typing import Optional
-from pythonjsonlogger import jsonlogger
-
-
-class RawLogger:
-    _instance = None
-    _initialized = False
-
-    def __new__(cls):
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-        return cls._instance
-
-    def __init__(self):
-        if not RawLogger._initialized:
-            self.logger = logging.getLogger("raw_docx")
-            self.logger.setLevel(logging.INFO)
-
-            # Create JSON formatter
-            formatter = jsonlogger.JsonFormatter(
-                fmt="%(asctime)s %(name)s %(levelname)s %(message)s",
-                datefmt="%Y-%m-%d %H:%M:%S",
-            )
-
-            # Console handler
-            console_handler = logging.StreamHandler(sys.stdout)
-            console_handler.setFormatter(formatter)
-            self.logger.addHandler(console_handler)
-
-            RawLogger._initialized = True
-
-    def setup_file_logging(self, log_dir: Optional[str] = None):
-        """Setup file logging in addition to console logging"""
-        if log_dir:
-            log_path = Path(log_dir)
-            log_path.mkdir(parents=True, exist_ok=True)
-            file_handler = logging.FileHandler(log_path / "raw_docx.log")
-            file_handler.setFormatter(
-                jsonlogger.JsonFormatter(
-                    fmt="%(asctime)s %(name)s %(levelname)s %(message)s",
-                    datefmt="%Y-%m-%d %H:%M:%S",
-                )
-            )
-            self.logger.addHandler(file_handler)
-
-    def info(self, message: str):
-        """Log info message"""
-        self.logger.info(message)
-
-    def warning(self, message: str):
-        """Log warning message"""
-        self.logger.warning(message)
-
-    def error(self, message: str):
-        """Log error message"""
-        self.logger.error(message)
-
-    def exception(self, message: str, exc: Exception):
-        """Log exception with message"""
-        self.logger.exception(message, exc_info=exc)
-
-
-# Create singleton instance
-logger = RawLogger()

raw_docx-0.5.0.dist-info/RECORD

@@ -1,20 +0,0 @@
-raw_docx/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-raw_docx/__version__.py,sha256=Wi_yZdt3UP6QrJT-sQRbjTz0HB_pmH5mlybhCDYuBGo,30
-raw_docx/docx_paragraph.py,sha256=2A0fqVNAWswJpI35WfaY2o07hP7Ks83NcpltAyLU31w,2752
-raw_docx/raw_document.py,sha256=VLx0-Z9jGwdYHMU227AKaT8UDRY_OHD7b2BRuw71x6M,2340
-raw_docx/raw_docx.py,sha256=LA94jADMXhRL1lcaz0-Fs69FYtAJdQLPJ57Lu92ZVf0,10258
-raw_docx/raw_image.py,sha256=GvR2hfgNkNnQCmEZ8SbMDWm-_CAyfk56eWF5l2OxQDw,1451
-raw_docx/raw_list.py,sha256=wA84muLMViYsj4gxMbwWM_aAQ9loYRixKgwPppJghrE,2209
-raw_docx/raw_list_item.py,sha256=L8b_eaag0aFisHozxW0dh8yynR5i-PhsltTtjHBnlhQ,591
-raw_docx/raw_logger.py,sha256=jKc5Ph3SNbXjO6sNq_q6BuUcZuIuKk8pbHp7mIFWRXg,2059
-raw_docx/raw_paragraph.py,sha256=GOxq4n68mpG11kxw5_89UmGqvTV_BSa8E9A15BaEroI,1075
-raw_docx/raw_run.py,sha256=0PJHiZIm1QclZfjdsrPPLSL7_GYoX8jSa6JvcfcOcWc,479
-raw_docx/raw_section.py,sha256=_ONvR5Fyuif4vZs1LnE7Y67pX29JKWM13YB8Wy8di9o,3942
-raw_docx/raw_table.py,sha256=qm-Ap1AOHRuOxiUgHsI6uV4GeCNEJrE0Z3TZ8rXbffg,1579
-raw_docx/raw_table_cell.py,sha256=pXe7FCfEmbqdktBGfkDrvMsbEie8FaGNQbRl_ooms0Q,1887
-raw_docx/raw_table_row.py,sha256=m8SoLyVlKLjd_Vqa_U79A2wi8Wout8spgyusqJm79Kc,1297
-raw_docx-0.5.0.dist-info/LICENSE,sha256=OXLcl0T2SZ8Pmy2_dmlvKuetivmyPd5m1q-Gyd-zaYY,35149
-raw_docx-0.5.0.dist-info/METADATA,sha256=Ug8ah1qQKDF8KPvZqp0FD0cxOPfOOy0i1JhFIq_x_c0,1204
-raw_docx-0.5.0.dist-info/WHEEL,sha256=jB7zZ3N9hIM9adW7qlTAyycLYW9npaWKLRzaoVcLKcM,91
-raw_docx-0.5.0.dist-info/top_level.txt,sha256=Xl3dspPM9DBVj8clfdkHG7N4nNjNXeUmB4HcXAwOe60,9
-raw_docx-0.5.0.dist-info/RECORD,,