Fix EPUB2 HTML charset metadata

Author: nfvelten

scripts/kindle_epub_fixer.py

@@ -118,31 +118,45 @@ def exit_if_cancelled() -> None:
             ...
         sys.exit(0)
 
+LOCK_FILE_PATH = os.path.join(tempfile.gettempdir(), 'kindle_epub_fixer.lock')
+lock_acquired = False
+
 ### LOCK FILES
 # Creates a lock file unless one already exists meaning an instance of the script is
 # already running, then the script is closed, the user is notified and the program
 # exits with code 2
-try:
-    lock = open(tempfile.gettempdir() + '/kindle_epub_fixer.lock', 'x')
-    lock.close()
-except FileExistsError:
-    print_and_log("[cwa-kindle-epub-fixer] CANCELLING... kindle-epub-fixer was initiated but is already running")
-    logger.info(f"\nCWA Kindle EPUB Fixer Service - Run Ended: {datetime.now()}")
-    sys.exit(2)
+def acquire_lock():
+    global lock_acquired
+    try:
+        with open(LOCK_FILE_PATH, 'x'):
+            pass
+        lock_acquired = True
+    except FileExistsError:
+        print_and_log("[cwa-kindle-epub-fixer] CANCELLING... kindle-epub-fixer was initiated but is already running")
+        logger.info(f"\nCWA Kindle EPUB Fixer Service - Run Ended: {datetime.now()}")
+        sys.exit(2)
 
 # Defining function to delete the lock on script exit
 def removeLock():
+    global lock_acquired
+    if not lock_acquired:
+        return
     try:
-        os.remove(tempfile.gettempdir() + '/kindle_epub_fixer.lock')
+        os.remove(LOCK_FILE_PATH)
     except FileNotFoundError:
         ...
+    finally:
+        lock_acquired = False
 
 # Will automatically run when the script exits
 atexit.register(removeLock)
 
 
 class EPUBFixer:
     def __init__(self, manually_triggered:bool=False, current_position:str=None):
+        if not lock_acquired:
+            acquire_lock()
+
         self.manually_triggered = manually_triggered
         self.current_position = current_position # string in the form of "n/n"
 
@@ -311,24 +325,46 @@ def _update_html_charset(self, content: str, target_encoding: str) -> str:
         if charset.startswith('utf-16'):
             charset = 'utf-16'
 
-        http_equiv_pattern = re.compile(
-            r'(<meta[^>]+http-equiv=["\']content-type["\'][^>]*content=["\'][^"\']*charset=)([^"\'>\s;]+)([^"\']*["\'][^>]*>)',
-            re.IGNORECASE
-        )
-        if http_equiv_pattern.search(content):
-            return http_equiv_pattern.sub(rf"\1{charset}\3", content, count=1)
+        http_equiv_meta = f'<meta http-equiv="Content-Type" content="text/html; charset={charset}" />'
+        meta_tag_pattern = re.compile(r'<meta\b[^>]*>', re.IGNORECASE)
+        http_equiv_pattern = re.compile(r'\bhttp-equiv\s*=\s*["\']content-type["\']', re.IGNORECASE)
+        content_attr_pattern = re.compile(r'\bcontent\s*=\s*(["\'])(.*?)\1', re.IGNORECASE | re.DOTALL)
+        charset_pattern = re.compile(r'(charset\s*=\s*)[^;\s"\']+', re.IGNORECASE)
+        replaced_http_equiv = False
+
+        def update_http_equiv(match: re.Match) -> str:
+            nonlocal replaced_http_equiv
+            tag = match.group(0)
+            if replaced_http_equiv or not http_equiv_pattern.search(tag):
+                return tag
+
+            content_match = content_attr_pattern.search(tag)
+            if not content_match or not charset_pattern.search(content_match.group(2)):
+                return tag
+
+            content_value = charset_pattern.sub(
+                lambda charset_match: f"{charset_match.group(1)}{charset}",
+                content_match.group(2),
+                count=1,
+            )
+            replaced_http_equiv = True
+            return tag[:content_match.start(2)] + content_value + tag[content_match.end(2):]
+
+        updated_content = meta_tag_pattern.sub(update_http_equiv, content)
+        if replaced_http_equiv:
+            return updated_content
 
-        meta_charset_pattern = re.compile(r'<meta[^>]+charset=["\']?[^"\'>\s]+[^>]*>', re.IGNORECASE)
+        meta_charset_pattern = re.compile(r'<meta\b[^>]+charset=["\']?[^"\'>\s]+[^>]*>', re.IGNORECASE)
         if meta_charset_pattern.search(content):
-            return meta_charset_pattern.sub(f'<meta charset="{charset}">', content, count=1)
+            return meta_charset_pattern.sub(http_equiv_meta, content, count=1)
 
         head_pattern = re.compile(r'<head[^>]*>', re.IGNORECASE)
         match = head_pattern.search(content)
         if match:
             insert_at = match.end()
-            return content[:insert_at] + f"\n    <meta charset=\"{charset}\">" + content[insert_at:]
+            return content[:insert_at] + f"\n    {http_equiv_meta}" + content[insert_at:]
 
-        return f"<meta charset=\"{charset}\">\n" + content
+        return content
 
     def _extract_book_info_from_path(self, file_path: str) -> tuple[int | None, str]:
         """Extract book ID and format from file path.
@@ -1152,6 +1188,8 @@ def get_all_epubs_in_library() -> list[str]:
 
 
 def main():
+    acquire_lock()
+
     parser = argparse.ArgumentParser(
         prog='kindle-epub-fixer',
         description='Checks the encoding of a given EPUB file and automatically corrects any errors that could \

tests/unit/test_kindle_epub_fixer.py

@@ -0,0 +1,111 @@
+# Calibre-Web Automated – fork of Calibre-Web
+# Copyright (C) 2018-2026 Calibre-Web contributors
+# Copyright (C) 2024-2026 Calibre-Web Automated contributors
+# SPDX-License-Identifier: GPL-3.0-or-later
+# See CONTRIBUTORS for full list of authors.
+
+import sys
+from pathlib import Path
+from xml.etree import ElementTree
+
+import pytest
+
+pytestmark = pytest.mark.unit
+
+project_root = Path(__file__).parent.parent.parent
+scripts_dir = project_root / "scripts"
+sys.path.insert(0, str(scripts_dir))
+
+import kindle_epub_fixer
+from kindle_epub_fixer import EPUBFixer
+
+
+def _update_html_charset(content: str, target_encoding: str = "utf-8") -> str:
+    fixer = EPUBFixer.__new__(EPUBFixer)
+    return fixer._update_html_charset(content, target_encoding)
+
+
+def _fix_html_entry(content: str) -> tuple[str, list[str]]:
+    fixer = EPUBFixer.__new__(EPUBFixer)
+    filename = "OPS/chapter.html"
+    fixer.files = {filename: content}
+    fixer.file_target_encodings = {filename: "utf-8"}
+    fixer.fixed_problems = []
+
+    fixer.fix_encoding()
+
+    return fixer.files[filename], fixer.fixed_problems
+
+
+def _assert_well_formed_xml(content: str) -> None:
+    ElementTree.fromstring(content)
+
+
+def test_constructor_acquires_fixer_lock(monkeypatch, tmp_path):
+    class FakeCwaDb:
+        cwa_settings = {"kindle_epub_fixer_aggressive": 0}
+
+    lock_path = tmp_path / "kindle_epub_fixer.lock"
+    monkeypatch.setattr(kindle_epub_fixer, "LOCK_FILE_PATH", str(lock_path))
+    monkeypatch.setattr(kindle_epub_fixer, "lock_acquired", False)
+    monkeypatch.setattr(kindle_epub_fixer, "CWA_DB", FakeCwaDb)
+
+    EPUBFixer()
+
+    assert lock_path.exists()
+    assert kindle_epub_fixer.lock_acquired is True
+
+    kindle_epub_fixer.removeLock()
+    assert not lock_path.exists()
+    assert kindle_epub_fixer.lock_acquired is False
+
+
+def test_updates_http_equiv_charset_when_content_attribute_comes_first():
+    content = (
+        '<html><head><meta content="text/html; charset=WINDOWS-1252" '
+        'http-equiv="Content-Type"/></head><body></body></html>'
+    )
+
+    updated = _update_html_charset(content)
+
+    assert 'content="text/html; charset=utf-8"' in updated
+    assert 'http-equiv="Content-Type"' in updated
+    _assert_well_formed_xml(updated)
+
+
+def test_replaces_html5_meta_charset_with_xhtml_compatible_meta():
+    content = '<html><head><meta charset="windows-1252"></head><body></body></html>'
+
+    updated = _update_html_charset(content)
+
+    assert '<meta charset="utf-8">' not in updated
+    assert '<meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' in updated
+    _assert_well_formed_xml(updated)
+
+
+def test_inserts_xhtml_compatible_meta_inside_head():
+    content = '<html><head></head><body></body></html>'
+
+    updated = _update_html_charset(content)
+
+    assert '<head>\n    <meta http-equiv="Content-Type" content="text/html; charset=utf-8" />' in updated
+    _assert_well_formed_xml(updated)
+
+
+def test_leaves_html_without_head_unchanged():
+    content = '<html><body><p>No head element</p></body></html>'
+
+    assert _update_html_charset(content) == content
+
+
+def test_fix_encoding_keeps_html_named_epub_content_well_formed():
+    content = (
+        '<html><head><meta content="text/html; charset=WINDOWS-1252" '
+        'http-equiv="Content-Type"/></head><body><p>Chapter</p></body></html>'
+    )
+
+    updated, fixed_problems = _fix_html_entry(content)
+
+    assert fixed_problems == ["Updated HTML charset in OPS/chapter.html to utf-8"]
+    assert 'content="text/html; charset=utf-8"' in updated
+    _assert_well_formed_xml(updated)