9f53616a · permissionBRICK/obsidian-epub-pipline

Dockerfile+3 -1 Viewed

 COPY requirements.txt /app/
 RUN pip install --no-cache-dir -r requirements.txt
 COPY main.py epub_builder.py generate_reference_doc.py /app/
 COPY center-v.lua /app/
 +COPY pagebreak.lua /app/
 COPY epub-style.css /app/
 +RUN python generate_reference_doc.py
 # /vault  - mount your markdown source folder here (read-write for flag reset)
 # /output - mount your EPUB destination folder here

README.md+1 -1 Viewed

 . The container scans the mounted vault under `/vault/<CREATIVE_FOLDER>`.
 . Each story folder is identified by a `metadata.md` file with YAML frontmatter.
 . If that frontmatter contains `export: true`, the container merges the sibling chapter `.md` files in that folder and exports a DOCX with `pandoc`, using a custom reference document so headings are black and the document uses Times New Roman instead of the default Office theme.
 . That DOCX is then converted into EPUB and MOBI with Calibre's `ebook-convert`.
 . The finished files are written to `/output`, with `.docx` in the root plus `/output/epub` and `/output/mobi` subfolders for the other formats. All generated files are set to mode `0644` so they are readable by all users.
 . The container resets `export: false` in the story's `metadata.md`.

epub_builder.py+32 -6 Viewed

 import re
 import subprocess
 import tempfile
 +import unicodedata
 from pathlib import Path
 from typing import Optional

 logger = logging.getLogger(__name__)
 METADATA_FILENAME = "metadata.md"
 DEFAULT_OUTPUT_FILE_MODE = 0o6440o664
 EPUB_SUBDIR = "epub"
 MOBI_SUBDIR = "mobi"
 +REFERENCE_DOC_PATH = Path("/app/reference.docx")
 +DEFAULT_OUTPUT_UID = 99
 +DEFAULT_OUTPUT_GID = 100
 def parse_frontmatter(text: str) -> dict:

             continue
         if i > 0 and add_page_breaks:
 -            merged_parts.append('\n\n<div style="page-break-before: always;"></div>\n\n')
 +            # Use Pandoc's explicit page break marker so DOCX gets a real break.
 +            merged_parts.append("\n\n\\newpage\n\n")
         merged_parts.append(content)
     return "\n\n".join(merged_parts)
 +def normalize_text_for_docx(text: str) -> str:
 +    """Normalize markdown text before DOCX export.
++
 +    NFC is a conservative choice that can reduce weirdness around combining
 +    characters without stripping the visual effect from decorated text.
 +    """
 +    return unicodedata.normalize("NFC", text)
++
++
 def sanitize_title(title: str) -> str:
     """Convert a story title into a safe base filename."""
     return re.sub(r"[^\w\s-]", "", title).strip()

         os.chmod(path, DEFAULT_OUTPUT_FILE_MODE)
 +def set_output_ownership(*paths: Path):
 +    """Set predictable ownership on generated output paths."""
 +    for path in paths:
 +        os.chown(path, DEFAULT_OUTPUT_UID, DEFAULT_OUTPUT_GID)
++
++
 def run_command(cmd: list[str], title: str, output_label: str) -> bool:
     """Run an external command and log any failure details."""
     logger.debug(f"Running: {' '.join(cmd)}")

     story: dict,
     output_dir: Path,
     lua_filter: Optional[Path] = None,
 +    pagebreak_filter: Optional[Path] = None,
     css_file: Optional[Path] = None,
 ) -> Optional[dict[str, Path]]:
     """Build DOCX, EPUB, and MOBI outputs for a story."""

     output_dir.mkdir(parents=True, exist_ok=True)
     epub_dir.mkdir(parents=True, exist_ok=True)
     mobi_dir.mkdir(parents=True, exist_ok=True)
 +    set_output_ownership(output_dir, epub_dir, mobi_dir)
     if not story["chapters"]:
         logger.warning(f"No chapters found for '{title}', skipping")

     logger.info(f"Building book files: '{title}' ({len(story['chapters'])} chapters)")
     merged_content = normalize_text_for_docx(merge_chapters(story["chapters"]))
     cover_path = get_cover_path(story)
     with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as tmp:

             "-o",
             str(docx_file),
             "--from",
             "markdown+raw_html+raw_tex",
             "--to",
             "docx",
             "--metadata",

             f"author={author}",
             "--metadata",
             f"lang={language}",
 -            "--toc",
 -            "--toc-depth=1",
             "--wrap=none",
+        ]
 +        if REFERENCE_DOC_PATH.exists():
 +            docx_cmd.extend(["--reference-doc", str(REFERENCE_DOC_PATH)])
++
         if lua_filter and lua_filter.exists():
             docx_cmd.extend(["--lua-filter", str(lua_filter)])
 +        if pagebreak_filter and pagebreak_filter.exists():
 +            docx_cmd.extend(["--lua-filter", str(pagebreak_filter)])
         if not run_command(docx_cmd, title, "DOCX"):
             return None

         logger.info(f"MOBI created: {mobi_file}")
         set_output_permissions(docx_file, epub_file, mobi_file)
 +        set_output_ownership(docx_file, epub_file, mobi_file)
         return {"docx": docx_file, "epub": epub_file, "mobi": mobi_file}
     except subprocess.TimeoutExpired:

generate_reference_doc.py+55 -0 Viewed

 +from docx import Document
 +from docx.enum.style import WD_STYLE_TYPE
 +from docx.oxml.ns import qn
 +from docx.shared import Pt, RGBColor
++
++
 +def set_font(font, name: str, size_pt: int, *, bold: bool = False):
 +    font.name = name
 +    font.size = Pt(size_pt)
 +    font.bold = bold
 +    font.color.rgb = RGBColor(0x00, 0x00, 0x00)
++
++
 +def set_run_fonts(style, name: str):
 +    r_pr = style.element.get_or_add_rPr()
 +    r_fonts = r_pr.get_or_add_rFonts()
 +    r_fonts.set(qn("w:ascii"), name)
 +    r_fonts.set(qn("w:hAnsi"), name)
 +    r_fonts.set(qn("w:eastAsia"), name)
 +    r_fonts.set(qn("w:cs"), name)
++
++
 +def style_paragraph(style, name: str, size_pt: int, *, bold: bool = False, space_before: int = 0, space_after: int = 0):
 +    set_font(style.font, name, size_pt, bold=bold)
 +    set_run_fonts(style, name)
 +    fmt = style.paragraph_format
 +    fmt.space_before = Pt(space_before)
 +    fmt.space_after = Pt(space_after)
++
++
 +doc = Document()
 +styles = doc.styles
++
 +normal = styles["Normal"]
 +style_paragraph(normal, "Times New Roman", 12)
++
 +title = styles["Title"]
 +style_paragraph(title, "Times New Roman", 22, bold=True, space_after=12)
++
 +heading1 = styles["Heading 1"]
 +style_paragraph(heading1, "Times New Roman", 18, bold=True, space_before=18, space_after=10)
++
 +heading2 = styles["Heading 2"]
 +style_paragraph(heading2, "Times New Roman", 16, bold=True, space_before=14, space_after=8)
++
 +heading3 = styles["Heading 3"]
 +style_paragraph(heading3, "Times New Roman", 14, bold=True, space_before=12, space_after=6)
++
 +if "First Paragraph" not in [style.name for style in styles]:
 +    styles.add_style("First Paragraph", WD_STYLE_TYPE.PARAGRAPH)
++
 +first_paragraph = styles["First Paragraph"]
 +style_paragraph(first_paragraph, "Times New Roman", 12)
++
 +doc.save("reference.docx")

main.py+7 -2 Viewed

 import time
 from pathlib import Path
 from epub_builder import build_outputs, discover_stories, set_output_ownership, write_frontmatter
 # ── Configuration from environment variables ──────────────────────────

 OUTPUT_DIR = os.environ.get("OUTPUT_DIR", "/output")
 LUA_FILTER_PATH = os.environ.get("LUA_FILTER_PATH", "/app/center-v.lua")
 +PAGEBREAK_FILTER_PATH = os.environ.get("PAGEBREAK_FILTER_PATH", "/app/pagebreak.lua")
 CSS_FILE_PATH = os.environ.get("CSS_FILE_PATH", "/app/epub-style.css")
 # How often to scan for export flags (seconds)

     output_path = Path(OUTPUT_DIR)
     lua_filter = Path(LUA_FILTER_PATH) if LUA_FILTER_PATH else None
 +    pagebreak_filter = Path(PAGEBREAK_FILTER_PATH) if PAGEBREAK_FILTER_PATH else None
     css_file = Path(CSS_FILE_PATH) if CSS_FILE_PATH else None
     for story in to_export:

             story=story,
             output_dir=output_path,
             lua_filter=lua_filter,
 +            pagebreak_filter=pagebreak_filter,
             css_file=css_file if css_file and css_file.exists() else None,
+        )

     logger.info(f"Poll interval: {POLL_INTERVAL}s")
     vault_path = Path(VAULT_PATH)
 -    Path(OUTPUT_DIR).mkdir(parents=True, exist_ok=True)
 +    output_path = Path(OUTPUT_DIR)
 +    output_path.mkdir(parents=True, exist_ok=True)
 +    set_output_ownership(output_path)
     if not vault_path.exists():
         logger.error(f"Vault path does not exist: {vault_path}")

pagebreak.lua+39 -0 Viewed

 +-- pagebreak.lua
 +-- Converts explicit page break markers into format-specific page breaks.
++
 +local DOCX_PAGEBREAK = [[
 +<w:p>
 +  <w:r>
 +    <w:br w:type="page"/>
 +  </w:r>
 +</w:p>
 +]]
++
 +local HTML_PAGEBREAK = '<div style="page-break-before: always;"></div>'
++
 +local function is_pagebreak(el)
 +  return (
 +    (el.t == "RawBlock" and el.format == "tex" and (el.text == "\\newpage" or el.text == "\\pagebreak")) or
 +    (el.t == "Para" and #el.content == 1 and el.content[1].t == "Str" and el.content[1].text == "\f")
 +  )
 +end
++
 +function RawBlock(el)
 +  if el.format == "tex" and (el.text == "\\newpage" or el.text == "\\pagebreak") then
 +    if FORMAT == "docx" or FORMAT == "openxml" then
 +      return pandoc.RawBlock("openxml", DOCX_PAGEBREAK)
 +    elseif FORMAT == "epub" or FORMAT == "epub3" or FORMAT == "html" or FORMAT == "html5" then
 +      return pandoc.RawBlock("html", HTML_PAGEBREAK)
 +    end
 +  end
 +end
++
 +function Para(el)
 +  if is_pagebreak(el) then
 +    if FORMAT == "docx" or FORMAT == "openxml" then
 +      return pandoc.RawBlock("openxml", DOCX_PAGEBREAK)
 +    elseif FORMAT == "epub" or FORMAT == "epub3" or FORMAT == "html" or FORMAT == "html5" then
 +      return pandoc.RawBlock("html", HTML_PAGEBREAK)
 +    end
 +  end
 +end

reference.docx+0 -0 Viewed

Binary file

requirements.txt+1 -0 Viewed

@@ -1 +1,2 @@
1	1	PyYAML>=6.0
	2	+python-docx>=1.1.2

Initial commit