v2 - docx and convert

5c0a85854a32a7593a2a8b6bac4a24efa3f6d353

permissionBRICK <you@example.com>

Parents: 15db1f8fa89eb8befa7ea04bbf369d17c66a5919

Dockerfile+1 -1 Viewed

 FROM python:3.12-slim
 RUN apt-get update && \
     apt-get install -y --no-install-recommends pandoc calibre && \
     rm -rf /var/lib/apt/lists/*
 RUN mkdir -p /app /output

README.md+7 -6 Viewed

 # Obsidian Markdown to EPUBEbook Pipeline
 This container watches a mounted markdown share for story folders and generates DOCX, EPUB, and MOBI files into a separate mounted output folder.
 ## How it works
 . 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 converts themexports toa EPUBDOCX with `pandoc`.
 -4. The finished EPUB is written to `/output` and explicitly set to mode `0644` so it is readable by all users.
 +4. That DOCX is then converted into EPUB and MOBI with Calibre's `ebook-convert`.
 -5. The container resets `export: false` in the story's `metadata.md`.
 +5. 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.
 +6. The container resets `export: false` in the story's `metadata.md`.
 ## Story layout

 | `VAULT_PATH` | `/vault` | Mounted source folder |
 | `OUTPUT_DIR` | `/output` | Mounted output folder |
 | `LUA_FILTER_PATH` | `/app/center-v.lua` | Pandoc Lua filter |
 | `CSS_FILE_PATH` | `/app/epub-style.css` | EPUBExtra stylesheet used during EPUB and MOBI conversion |
 ## Docker Hub publishing flow

epub_builder.py+150 -119 Viewed

 """
 Story discovery and EPUBebook build pipeline.
 Scans the vault for metadata.md files (with YAML frontmatter), discovers
 chapter files, merges them into a single markdown document, andexports convertsa DOCX
 -to EPUB via pandoc.
 +via pandoc, then converts that DOCX to EPUB and MOBI.
 """
 import logging

 METADATA_FILENAME = "metadata.md"
 DEFAULT_OUTPUT_FILE_MODE = 0o644
 +EPUB_SUBDIR = "epub"
 +MOBI_SUBDIR = "mobi"
 def parse_frontmatter(text: str) -> dict:
     """Extract YAML frontmatter from a markdown file."""
+-
 -    Expects the file to start with '---', followed by YAML, closed by '---'.
 -    Returns the parsed dict, or {} if no valid frontmatter found.
 -    """
     text = text.strip()
     if not text.startswith("---"):
         return {}
 -    # Find the closing ---
++
     end = text.find("---", 3)
     if end == -1:
         return {}
++
     yaml_block = text[3:end].strip()
     try:
         return yaml.safe_load(yaml_block) or {}

 def write_frontmatter(metadata: dict, original_text: str) -> str:
     """Replace the YAML frontmatter in a markdown file, preserving body content."""
+-
 -    If there's content after the frontmatter, it's kept intact.
 -    """
     body = ""
     original_text = original_text.strip()
     if original_text.startswith("---"):

 def natural_sort_key(path: Path) -> tuple:
     """Sort chapter files by their chapter number naturallywhen possible."""
+-
 -    Handles filenames like 'Chapter 1 - Title.md', 'Chapter 10 - Title.md', etc.
 -    Falls back to alphabetical if no chapter number is found.
 -    """
     name = path.stem
 -    # Try to extract chapter number from common patterns
++
     match = re.search(r'"[Cc]hapter\s+(\d+)'", name)
     if match:
         return (0, int(match.group(1)), name)
 -    # Try plain number at start
++
     match = re.match(r'"(\d+)'", name)
     if match:
         return (0, int(match.group(1)), name)
 -    # Fallback: alphabetical, but after numbered chapters
++
     return (1, 0, name)
 def discover_stories(vault_path: Path, creative_folder: str = "Creative") -> list[dict]:
     """Recursively scan for metadata.md files under the creative folder."""
+-
 -    Each metadata.md (with YAML frontmatter) marks a story directory.
 -    All other .md files in the same directory (not subfolders) are treated
 -    as chapter files.
+-
 -    Returns a list of story dicts with keys:
 -        - path: Path to the story directory
 -        - metadata_file: Path to the metadata.md
 -        - metadata: Parsed frontmatter dict
 -        - metadata_raw: Raw text of the metadata.md file
 -        - chapters: List of chapter file Paths, sorted by chapter number
 -    """
     creative_path = vault_path / creative_folder
     if not creative_path.exists():
         logger.warning(f"Creative folder not found: {creative_path}")

             logger.warning(f"No valid frontmatter in {metadata_file}, skipping")
             continue
 -        # Collect .md files in the story directory (not subdirectories)
         chapters = sorted(
             [f for f in story_dir.iterdir() if f.suffix == ".md" and f.name != METADATA_FILENAME],
 -             if f.suffix == ".md" and f.name != METADATA_FILENAME],
 +            key=natural_sort_key,
 -            key=natural_sort_key
+        )
         stories.append({
 +            {
                 "path": story_dir,
                 "metadata_file": metadata_file,
                 "metadata": metadata,
                 "metadata_raw": raw_text,
                 "chapters": chapters,
 -        })
 +            }
 -        logger.info(f"Discovered story: {metadata.get('title', story_dir.name)} "
 +        )
 -                     f"({len(chapters)} chapters)")
 +        logger.info(
 +            f"Discovered story: {metadata.get('title', story_dir.name)} "
 +            f"({len(chapters)} chapters)"
 +        )
     return stories
 def merge_chapters(chapters: list[Path], add_page_breaks: bool = True) -> str:
     """Merge chapter markdown files into a single document."""
+-
 -    Inserts pagebreak divs between chapters for pandoc to interpret.
 -    """
     merged_parts = []
     for i, chapter_file in enumerate(chapters):

             continue
         if i > 0 and add_page_breaks:
 -            # Pandoc-compatible page break (works for EPUB and DOCX)
             merged_parts.append('\n\n<div style="page-break-before: always;"></div>\n\n')
         merged_parts.append(content)

     return "\n\n".join(merged_parts)
 -def build_epub(story: dict, output_dir: Path, lua_filter: Optional[Path] = None,
 +def sanitize_title(title: str) -> str:
 -               css_file: Optional[Path] = None) -> Optional[Path]:
 +    """Convert a story title into a safe base filename."""
 -    """Build an EPUB from a story's merged chapters using pandoc.
 +    return re.sub(r"[^\w\s-]", "", title).strip()
 -    Args:
 -        story: Story dict from discover_stories()
 -        output_dir: Directory to write the EPUB to
 -        lua_filter: Path to the center-v.lua filter
 -        css_file: Optional custom CSS file for EPUB styling
 -    Returns:
 +def get_cover_path(story: dict) -> Optional[Path]:
 -        Path to the generated EPUB, or None on failure.
 +    """Resolve a configured or auto-detected cover image for the story."""
 -    """
 +    metadata = story["metadata"]
 +    cover = metadata.get("cover")
++
 +    if cover:
 +        cover_path = story["path"] / cover
 +        if cover_path.exists():
 +            return cover_path
 +        logger.warning(f"Cover image specified but not found: {cover_path}")
 +        return None
++
 +    for ext in ["jpg", "jpeg", "png"]:
 +        candidate = story["path"] / f"cover.{ext}"
 +        if candidate.exists():
 +            return candidate
++
 +    return None
++
++
 +def set_output_permissions(*paths: Path):
 +    """Set predictable readable permissions on generated output files."""
 +    for path in paths:
 +        os.chmod(path, DEFAULT_OUTPUT_FILE_MODE)
++
++
 +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)}")
++
 +    result = subprocess.run(
 +        cmd,
 +        capture_output=True,
 +        text=True,
 +        timeout=240,
 +    )
++
 +    if result.returncode != 0:
 +        logger.error(f"{output_label} build failed for '{title}':\n{result.stderr}")
 +        return False
++
 +    if result.stderr:
 +        logger.warning(f"{output_label} warnings for '{title}':\n{result.stderr}")
++
 +    return True
++
++
 +def build_outputs(
 +    story: dict,
 +    output_dir: Path,
 +    lua_filter: Optional[Path] = None,
 +    css_file: Optional[Path] = None,
 +) -> Optional[dict[str, Path]]:
 +    """Build DOCX, EPUB, and MOBI outputs for a story."""
     metadata = story["metadata"]
     title = metadata.get("title", story["path"].name)
     author = metadata.get("author", "Unknown Author")
     language = metadata.get("language", "en")
 -    # Sanitize filename
 +    safe_title = sanitize_title(title)
 -    safe_title = re.sub(r'[^\w\s-]', '', title).strip()
 +    epub_dir = output_dir / EPUB_SUBDIR
     output_filemobi_dir = output_dir / f"{safe_title}.epub"MOBI_SUBDIR
 +    docx_file = output_dir / f"{safe_title}.docx"
 +    epub_file = epub_dir / f"{safe_title}.epub"
 +    mobi_file = mobi_dir / f"{safe_title}.mobi"
     output_dir.mkdir(parents=True, exist_ok=True)
 +    epub_dir.mkdir(parents=True, exist_ok=True)
 +    mobi_dir.mkdir(parents=True, exist_ok=True)
     if not story["chapters"]:
         logger.warning(f"No chapters found for '{title}', skipping")
         return None
     logger.info(f"Building EPUBbook files: '{title}' ({len(story['chapters'])} chapters)")
 -    # Merge all chapters into a single markdown string
     merged_content = merge_chapters(story["chapters"])
 +    cover_path = get_cover_path(story)
 -    # Write merged content to a temp file for pandoc
 +    with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False, encoding="utf-8") as tmp:
 -    with tempfile.NamedTemporaryFile(mode="w", suffix=".md", delete=False,
 -                                      encoding="utf-8") as tmp:
         tmp.write(merged_content)
         tmp_path = tmp.name
     try:
 -        # Build pandoc command
 +        docx_cmd = [
 -        cmd = [
             "pandoc",
             tmp_path,
             "-o", str(output_file),
 -            "--from", "markdown+raw_html",
 +            str(docx_file),
             "--to", "epub3from",
 -            "--metadata", f"title={title}",
 +            "markdown+raw_html",
             "--metadata", f"author={author}to",
 -            "--metadata", f"lang={language}",
 +            "docx",
 +            "--metadata",
 +            f"title={title}",
 +            "--metadata",
 +            f"author={author}",
 +            "--metadata",
 +            f"lang={language}",
             "--toc",
             "--toc-depth=1",
 -            "--split-level=1",
             "--wrap=none",
+        ]
 -        # Add cover image: use metadata field if set, otherwise auto-detect
 +        if lua_filter and lua_filter.exists():
 -        cover = metadata.get("cover")
 +            docx_cmd.extend(["--lua-filter", str(lua_filter)])
 -        cover_path = None
++
 -        if cover:
 +        if not run_command(docx_cmd, title, "DOCX"):
 -            cover_path = story["path"] / cover
 +            return None
 -            if not cover_path.exists():
 +        logger.info(f"DOCX created: {docx_file}")
 -                logger.warning(f"Cover image specified but not found: {cover_path}")
++
                 cover_path        base_convert_cmd = None[
 -        else:
 +            "--title",
 -            # Auto-detect cover.jpg / cover.png in the story folder
 +            title,
 -            for ext in ["jpg", "jpeg", "png"]:
 +            "--authors",
 -                candidate = story["path"] / f"cover.{ext}"
 +            author,
 -                if candidate.exists():
 +            "--language",
 -                    cover_path = candidate
 +            language,
 -                    break
 +            "--chapter",
 +            "//h:h1|//h:h2",
 +            "--level1-toc",
 +            "//h:h1",
 +            "--level2-toc",
 +            "//h:h2",
 +            "--max-toc-links",
 +            "500",
 +        ]
++
 +        epub_cmd = ["ebook-convert", str(docx_file), str(epub_file), *base_convert_cmd]
 +        mobi_cmd = ["ebook-convert", str(docx_file), str(mobi_file), *base_convert_cmd]
++
         if cover_path:
 -            cmd.extend(["--epub-cover-image", str(cover_path)])
             logger.info(f"Using cover image: {cover_path.name}")
 +            epub_cmd.extend(["--cover", str(cover_path)])
 +            mobi_cmd.extend(["--cover", str(cover_path)])
 -        # Add custom CSS
         if css_file and css_file.exists():
             cmdepub_cmd.extend(["--extra-css", str(css_file)])
+-
 +            mobi_cmd.extend(["--extra-css", str(css_file)])
 -        # Add lua filter for ~V~ handling
 -        if lua_filter and lua_filter.exists():
 -            cmd.extend(["--lua-filter", str(lua_filter)])
 -        logger.debug(f"Running: {' '.join(cmd)}")
 +        if not run_command(epub_cmd, title, "EPUB"):
 -        result = subprocess.run(
 -            cmd,
 -            capture_output=True,
 -            text=True,
 -            timeout=120,
 -        )
+-
 -        if result.returncode != 0:
 -            logger.error(f"Pandoc failed for '{title}':\n{result.stderr}")
             return None
 +        logger.info(f"EPUB created: {epub_file}")
 -        if result.stderr:
 +        if not run_command(mobi_cmd, title, "MOBI"):
 -            logger.warning(f"Pandoc warnings for '{title}':\n{result.stderr}")
 +            return None
 +        logger.info(f"MOBI created: {mobi_file}")
 -        # Keep generated books readable to any user sharing the mounted output.
 +        set_output_permissions(docx_file, epub_file, mobi_file)
 -        os.chmod(output_file, DEFAULT_OUTPUT_FILE_MODE)
 +        return {"docx": docx_file, "epub": epub_file, "mobi": mobi_file}
 -        logger.info(f"EPUB created: {output_file}")
 -        return output_file
     except subprocess.TimeoutExpired:
         logger.error(f"PandocBuild timed out for '{title}'")
 -        return None
     except Exception as e:
         logger.error(f"EPUB buildBuild failed for '{title}': {e}")
 -        return None
     finally:
         Path(tmp_path).unlink(missing_ok=True)
++
 +    return None

main.py+10 -13 Viewed

 #!/usr/bin/env python3
 """
 Obsidian EPUBebook Exporterexporter.
 Watches a mounted Obsidian vault for metadata.md files with `export: true`
 in their YAML frontmatter. When found, mergesit allbuilds chapterDOCX, .mdEPUB, filesand inMOBI thatfiles
 -folder into a single EPUB via pandoc, and writes it to the mounted output folder.
 +in the mounted output folder, then resets the flag back to false.
 -and resets the flag back to false.
+-
 -Designed to run as a small polling container with the source markdown share
 -and destination EPUB share mounted into it.
 """
 import logging

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

 def process_exports(vault_path: Path):
     """Scan for stories with export: true and build EPUBsebook outputs."""
     stories = discover_stories(vault_path, CREATIVE_FOLDER)
     to_export = [s for s in stories if s["metadata"].get("export") is True]

         title = story["metadata"].get("title", story["path"].name)
         logger.info(f"Export requested for: '{title}'")
         epub_pathbuilt_files = build_epubbuild_outputs(
             story=story,
             output_dir=output_path,
             lua_filter=lua_filter,
             css_file=css_file if css_file and css_file.exists() else None,
+        )
         if epub_pathbuilt_files:
 -            logger.info(f"Successfully exported: {epub_path}")
 +            created = ", ".join(str(path.name) for path in built_files.values())
 +            logger.info(f"Successfully exported: {created}")
             reset_export_flag(story)
         else:
             logger.error(f"Failed to export '{title}'")

 def main():
     logger.info("=" * 60)
     logger.info("Obsidian EPUBebook Exporterexporter starting up")
     logger.info("=" * 60)
     logger.info(f"Vault path: {VAULT_PATH}")
     logger.info(f"Creative folder: {CREATIVE_FOLDER}")