(no commit message provided)

Author: titusz

.gitignore

@@ -159,4 +159,5 @@ cython_debug/
 #  and can be added to the global gitignore or merged into this file.  For a more nuclear
 #  option (not recommended) you can uncomment the following to ignore the entire idea folder.
 .idea/
-
+scratch
+.aider*

README.md

@@ -1 +1 @@
-# accfix - EPUB accessibility fixer
+# accfix -  Automated accessibility fixes for EPUB

accfix/__init__.py

@@ -0,0 +1,115 @@
+from pathlib import Path
+from loguru import logger as log
+import streamlit as st
+import tempfile
+import subprocess
+import shutil
+import re
+
+ace_path = Path(shutil.which("ace"))
+ansi_escape = re.compile(r"\x1B[@-_][0-?]*[ -/]*[@-~]")
+
+
+def check_epub(fp):
+    # Run the ace command with subprocess.Popen
+    fp = Path(fp)
+    report_dir = fp.parent / f"{fp.stem}_report"
+    report_dir.mkdir(exist_ok=True)
+    report_file = report_dir / "report.json"
+
+    # Run ACE Check
+    cmd = [ace_path, "-f", "-o", report_dir, fp]
+    process = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.STDOUT, text=True)
+
+    log_output = []
+    for line in process.stdout:
+        stripped_line = ansi_escape.sub("", line).strip()
+        log.info(stripped_line)
+        log_output.append(line)
+        yield stripped_line
+
+    process.wait()
+    if process.returncode != 0:
+        log_output.append(f"Ace command failed with return code {process.returncode}")
+        yield f"Ace command failed with return code {process.returncode}"
+
+
+# def main():
+#     st.title("EPUB Accessibility Fixer")
+#     uploaded_file = st.file_uploader("Upload an EPUB file", type=["epub"])
+#
+#     if uploaded_file is not None:
+#         with tempfile.NamedTemporaryFile(delete=False, suffix=".epub") as tmp_file:
+#             tmp_file.write(uploaded_file.getbuffer())
+#             tmp_file_path = tmp_file.name
+#
+#         st.text("Checking EPUB for accessibility violations...")
+#
+#         # Placeholder for log messages
+#         log_placeholder = st.empty()
+#         log_lines = []
+#
+#         # Define the maximum number of lines to display
+#         max_log_lines = 6
+#
+#         for log_line in check_epub(tmp_file_path):
+#             # Add new log line to the list
+#             log_lines.append(log_line)
+#
+#             # Keep only the last 'max_log_lines' lines
+#             if len(log_lines) > max_log_lines:
+#                 log_lines = log_lines[-max_log_lines:]
+#
+#             # Join the log lines into a single string
+#             log_messages = "\n".join(log_lines)
+#
+#             # Update the log placeholder
+#             log_placeholder.text(log_messages)
+#
+#         st.text("Accessibility check completed.")
+#         # Placeholder for fixing process
+#         st.text("Fixing issues... (implementation required)")
+#         fixed_file_path = tmp_file_path.replace(".epub", "_fixed.epub")
+#
+#         # Example of saving fixed file (this should be replaced with actual fixing logic)
+#         with open(fixed_file_path, "wb") as fixed_file:
+#             fixed_file.write(uploaded_file.getbuffer())
+#
+#         st.text("Download the fixed EPUB file:")
+#         with open(fixed_file_path, "rb") as fixed_file:
+#             st.download_button(label="Download Fixed EPUB", data=fixed_file, file_name="fixed.epub")
+
+
+def main():
+    st.title("EPUB Accessibility Fixer")
+    uploaded_file = st.file_uploader("Upload an EPUB file", type=["epub"])
+
+    if uploaded_file is not None:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".epub") as tmp_file:
+            tmp_file.write(uploaded_file.getbuffer())
+            tmp_file_path = tmp_file.name
+
+        st.text("Checking EPUB for accessibility violations...")
+
+        # Placeholder for log messages
+        log_placeholder = st.empty()
+
+        for log_line in check_epub(tmp_file_path):
+            log_placeholder.text(log_line, append=True)
+
+        st.text("Accessibility check completed.")
+        # Placeholder for fixing process
+        st.text("Fixing issues... (implementation required)")
+        fixed_file_path = tmp_file_path.replace(".epub", "_fixed.epub")
+
+        # Example of saving fixed file (this should be replaced with actual fixing logic)
+        with open(fixed_file_path, "wb") as fixed_file:
+            fixed_file.write(uploaded_file.getbuffer())
+
+        st.text("Download the fixed EPUB file:")
+        with open(fixed_file_path, "rb") as fixed_file:
+            st.download_button(label="Download Fixed EPUB", data=fixed_file, file_name="fixed.epub")
+
+
+if __name__ == "__main__":
+    main()

accfix/app.py

@@ -0,0 +1,90 @@
+from pathlib import Path
+import zipfile
+from typing import Optional
+from lingua import LanguageDetectorBuilder
+from lxml import etree
+from subprocess import run
+import json
+
+
+detector = LanguageDetectorBuilder.from_all_languages().with_low_accuracy_mode().build()
+
+
+def is_epub(fp: str | Path) -> bool:
+    """Check if a file is an epub."""
+    fp = Path(fp)
+    with zipfile.ZipFile(fp, "r") as zf:
+        infolist = zf.infolist()
+        if not infolist or infolist[0].filename != "mimetype":
+            return False
+
+        info = infolist[0]
+        if info.file_size == 20 and zf.read(info) == b"application/epub+zip":
+            return True
+    return False
+
+
+def opf_path(fp: str | Path) -> Path:
+    """Determine OPF-File path within epub archive"""
+    fp = Path(fp)
+    with zipfile.ZipFile(fp, "r") as z:
+        with z.open("META-INF/container.xml", "r") as f:
+            xml_data = f.read()
+        tree = etree.fromstring(xml_data)
+        namespace = {"ns": "urn:oasis:names:tc:opendocument:xmlns:container"}
+        rootfile_element = tree.find(".//ns:rootfiles/ns:rootfile", namespaces=namespace)
+        result = rootfile_element.attrib["full-path"]
+    return Path(result)
+
+
+def read_opf(fp: str | Path):
+    """Read OPF-File from epub archive"""
+    fp = Path(fp)
+    opf_fp = opf_path(fp)  # use the existing function to determine the opf file's location
+    with zipfile.ZipFile(fp, "r") as z:
+        with z.open(opf_fp.as_posix(), "r") as f:
+            xml_data = f.read()
+    tree = etree.fromstring(xml_data)  # parse the opf file using lxml for editing
+    return tree
+
+
+def xml_text(xml: etree._Element) -> str | None:
+    """Extract plaintext content from XML tree"""
+    content = [t.strip() for t in xml.xpath("//text()") if t.strip()]
+    return "\n".join(content)
+
+
+def detect_lang(text: str) -> Optional[str]:
+    """Detect language of text and return ISO 639-1 code"""
+    detected_language = detector.detect_language_of(text)
+    if not detected_language:
+        return
+    return detected_language.iso_code_639_1.name.lower()
+
+
+def check(fp: str | Path) -> dict:
+    # Prepare output path
+    fp = Path(fp)
+    report_dir = fp.parent / f"{fp.stem}_report"
+    report_dir.mkdir(exist_ok=True)
+    report_file = report_dir / "report.json"
+
+    # Run ACE Check
+    cmd = ["ace", "-f", "-o", report_dir, fp]
+    run(cmd, shell=True)
+
+    # Return Result data
+    return json.load(report_file.open(encoding="utf-8"))
+
+
+if __name__ == "__main__":
+    file = Path("../scratch/test1.epub")
+    check(file)
+    # print(is_epub(file))
+    # opf_fp = opf_path(Path("../scratch/test1_fix.epub"))
+    # print(opf_fp)
+    # opf_tree = read_opf(file)
+    # print(opf_tree)
+    # print(detect_lang("Guten Tag. Wie geht es ihnen"))
+    # print(xml_text(opf_tree))
+    # print(check(Path("../scratch/test1_fix.epub")))

accfix/check.py

@@ -18,30 +18,19 @@ def __init__(self, path, clone=True):
         """
         self._path = Path(path)
         self.name = self._path.name
-        log.debug("Opening EPUB file: {}".format(self._path.name))
+        log.debug(f"Opening EPUB file: {self._path.name}")
         self._clone = None
         if clone:
             temp_dir = tempfile.mkdtemp()
             self._clone = Path(temp_dir) / self._path.name
             shutil.copy2(self._path, self._clone)
-            log.debug("Cloning EPUB file to: {}".format(self._clone.parent))
+            log.debug(f"Cloning EPUB file to: {self._clone.parent}")
         self._fs = fsspec.filesystem("zip", fo=str(self._clone if self._clone else self._path))
 
     def __repr__(self):
-        return 'Epub("{}")'.format(self._path.name)
+        return f'Epub("{self._path.name}")'
 
-    def write(self, path, content, mode="wb"):
-        # type: (str|Path, str|bytes, str) -> None
-        """Write content to a file within the EPUB.
-
-        :param path: The relative path of the file within the EPUB.
-        :param content: The content to write to the file.
-        :param mode: The mode to open the file.
-        """
-        path = Path(path)
-        log.debug(f"Writing to: {self.name}/{path}")
-        with self._fs.open(path.as_posix(), mode=mode) as file:
-            file.write(content)
+    def read(self, path, mode="rb"):
         # type: (str|Path, str) -> str | bytes
         """Read the content of a file from the EPUB.