pdf2epub 0.1.1 → 0.1.3

package/vendor/pdf2epub/modules/mark2epub.py

@@ -1,696 +0,0 @@
-import markdown
-import os
-from xml.dom import minidom
-import zipfile
-import sys
-import json
-from PIL import Image
-import regex as re
-from pathlib import Path
-from datetime import datetime, timezone
-import subprocess
-from typing import Dict, Optional
-from urllib.parse import quote
-from xml.sax.saxutils import escape as xml_escape
-import latex2mathml.converter
-
-def get_user_input(prompt: str, default: str = "") -> str:
-    """Get user input with a default value."""
-    user_input = input(f"{prompt} [{default}]: ").strip()
-    return user_input if user_input else default
-
-def get_metadata_from_user(existing_metadata: Optional[Dict] = None) -> Dict:
-    """Interactively collect metadata from user with defaults from existing metadata."""
-    if existing_metadata is None:
-        existing_metadata = {}
-    
-    metadata = existing_metadata.get("metadata", {})
-    
-    print("\nPlease provide the following metadata for your EPUB (press Enter to use default value):")
-    
-    fields = {
-        "dc:title": ("Title", metadata.get("dc:title", "Untitled Document")),
-        "dc:creator": ("Author(s)", metadata.get("dc:creator", "Unknown Author")),
-        "dc:identifier": ("Unique Identifier", metadata.get("dc:identifier", f"id-{datetime.now().strftime('%Y%m%d%H%M%S')}")),
-        "dc:language": ("Language (e.g., en, de, fr)", metadata.get("dc:language", "en")),
-        "dc:rights": ("Rights", metadata.get("dc:rights", "All rights reserved")),
-        "dc:publisher": ("Publisher", metadata.get("dc:publisher", "PDF2EPUB")),
-        "dc:date": ("Publication Date (YYYY-MM-DD)", metadata.get("dc:date", datetime.now().strftime("%Y-%m-%d")))
-    }
-    
-    updated_metadata = {}
-    for key, (prompt, default) in fields.items():
-        value = get_user_input(prompt, default)
-        updated_metadata[key] = value
-        
-    return {
-        "metadata": updated_metadata,
-        "default_css": existing_metadata.get("default_css", ["style.css"]),
-        "chapters": existing_metadata.get("chapters", []),
-        "cover_image": existing_metadata.get("cover_image", None)
-    }
-
-def review_markdown(markdown_path: Path) -> tuple[bool, str]:
-    """Ask user if they want to review the markdown file."""
-    content = markdown_path.read_text(encoding='utf-8')
-    
-    while True:
-        response = input("\nWould you like to review the markdown file before conversion? (y/n): ").lower()
-        if response in ['y', 'yes']:
-            try:
-                if sys.platform == 'darwin':
-                    subprocess.run(['open', str(markdown_path)], check=True)
-                elif os.name == 'posix':
-                    subprocess.run(['xdg-open', str(markdown_path)], check=True)
-                else:
-                    os.startfile(str(markdown_path))
-                
-                while True:
-                    proceed = input("\nPress Enter when you're done editing (or 'q' to abort): ").lower()
-                    if proceed == 'q':
-                        return False, content
-                    elif proceed == '':
-                        updated_content = markdown_path.read_text(encoding='utf-8')
-                        return True, updated_content
-            except Exception as e:
-                print(f"\nError opening markdown file: {e}")
-                print("Proceeding with conversion...")
-                return True, content
-        elif response in ['n', 'no']:
-            return True, content
-        else:
-            print("Please enter 'y' or 'n'")
-
-def build_image_lookup(images_dir: Path) -> dict:
-    """Build a {lowercase_name: actual_path} map for O(1) case-insensitive lookups."""
-    lookup = {}
-    try:
-        for entry in images_dir.iterdir():
-            lookup[entry.name.lower()] = entry
-    except FileNotFoundError:
-        pass
-    return lookup
-
-def process_markdown_for_images(markdown_text: str, work_dir: Path) -> tuple[str, list[str]]:
-    """Process markdown content to find image references."""
-    image_pattern = r'!\[(.*?)\]\((.*?)\)'
-    images_found = []
-    modified_text = markdown_text
-    images_dir = work_dir / 'images'
-    lookup = build_image_lookup(images_dir)
-
-    for match in re.finditer(image_pattern, markdown_text):
-        alt_text, image_path = match.groups()
-        img_path = Path(image_path.strip())
-
-        actual = lookup.get(img_path.name.lower())
-        if actual is not None:
-            images_found.append(actual.name)
-            new_ref = f'![{alt_text}](images/{actual.name})'
-            modified_text = modified_text.replace(match.group(0), new_ref)
-        else:
-            print(f"Warning: Image not found: {images_dir / img_path.name}")
-
-    return modified_text, images_found
-
-def copy_and_optimize_image(src_path: Path, dest_path: Path, max_dimension: int = 1800) -> None:
-    """Copy image to destination path with optimization for EPUB."""
-    try:
-        with Image.open(src_path) as img:
-            if img.mode == 'RGBA':
-                img = img.convert('RGB')
-                
-            ratio = min(max_dimension / max(img.size[0], img.size[1]), 1.0)
-            new_size = tuple(int(dim * ratio) for dim in img.size)
-            
-            if ratio < 1.0:
-                img = img.resize(new_size, Image.Resampling.LANCZOS)
-            
-            if src_path.suffix.lower() in ['.jpg', '.jpeg']:
-                img.save(dest_path, 'JPEG', quality=85, optimize=True)
-            elif src_path.suffix.lower() == '.png':
-                img.save(dest_path, 'PNG', optimize=True)
-            else:
-                dest_path = dest_path.with_suffix('.jpg')
-                img.save(dest_path, 'JPEG', quality=85, optimize=True)
-                
-    except Exception as e:
-        print(f"Error processing image {src_path}: {e}")
-        raise
-
-def update_package_manifest(doc: minidom.Document, image_filenames: list[str], 
-                          manifest: minidom.Element) -> None:
-    """
-    Update package manifest with image items, ensuring proper media types.
-    """
-    for i, image_filename in enumerate(image_filenames):
-        item = doc.createElement('item')
-        item.setAttribute('id', f"image-{i:05d}")
-        item.setAttribute('href', f"images/{image_filename}")
-        
-        # Set appropriate media type based on file extension
-        ext = Path(image_filename).suffix.lower()
-        if ext in ['.jpg', '.jpeg']:
-            media_type = 'image/jpeg'
-        elif ext == '.png':
-            media_type = 'image/png'
-        elif ext == '.gif':
-            media_type = 'image/gif'
-        else:
-            print(f"Warning: Unsupported image type {ext} for {image_filename}")
-            continue
-            
-        item.setAttribute('media-type', media_type)
-        manifest.appendChild(item)
-        
-def get_all_filenames(the_dir, extensions=[]):
-    if not os.path.exists(the_dir):
-        return []
-    all_files = [x for x in os.listdir(the_dir)]
-    all_files = [x for x in all_files if x.split(".")[-1] in extensions]
-    return all_files
-
-def get_packageOPF_XML(md_filenames=[], image_filenames=[], css_filenames=[], description_data=None):
-    doc = minidom.Document()
-
-    package = doc.createElement('package')
-    package.setAttribute('xmlns',"http://www.idpf.org/2007/opf")
-    package.setAttribute('version',"3.0")
-    package.setAttribute('xml:lang',"en")
-    package.setAttribute("unique-identifier","pub-id")
-
-    ## Now building the metadata
-
-    metadata = doc.createElement('metadata')
-    metadata.setAttribute('xmlns:dc', 'http://purl.org/dc/elements/1.1/')
-
-    for k,v in description_data["metadata"].items():
-        if len(v):
-            x = doc.createElement(k)
-            for metadata_type,id_label in [("dc:title","title"),("dc:creator","creator"),("dc:identifier","pub-id")]:
-                if k==metadata_type:
-                    x.setAttribute('id',id_label)
-            x.appendChild(doc.createTextNode(v))
-            metadata.appendChild(x)
-
-    # Required by EPUB 3: dcterms:modified timestamp
-    modified_meta = doc.createElement('meta')
-    modified_meta.setAttribute('property', 'dcterms:modified')
-    modified_meta.appendChild(doc.createTextNode(datetime.now(timezone.utc).strftime("%Y-%m-%dT%H:%M:%SZ")))
-    metadata.appendChild(modified_meta)
-
-
-    ## Now building the manifest
-
-    manifest = doc.createElement('manifest')
-
-    ## TOC.xhtml file for EPUB 3
-    x = doc.createElement('item')
-    x.setAttribute('id',"toc")
-    x.setAttribute('properties',"nav")
-    x.setAttribute('href',"TOC.xhtml")
-    x.setAttribute('media-type',"application/xhtml+xml")
-    manifest.appendChild(x)
-
-    ## Ensure retrocompatibility by also providing a TOC.ncx file
-    x = doc.createElement('item')
-    x.setAttribute('id',"ncx")
-    x.setAttribute('href',"toc.ncx")
-    x.setAttribute('media-type',"application/x-dtbncx+xml")
-    manifest.appendChild(x)
-
-    x = doc.createElement('item')
-    x.setAttribute('id',"titlepage")
-    x.setAttribute('href',"titlepage.xhtml")
-    x.setAttribute('media-type',"application/xhtml+xml")
-    manifest.appendChild(x)
-
-    for i,md_filename in enumerate(md_filenames):
-        x = doc.createElement('item')
-        x.setAttribute('id',"s{:05d}".format(i))
-        x.setAttribute('href', quote("s{:05d}-{}.xhtml".format(i, md_filename.split(".")[0])))
-        x.setAttribute('media-type',"application/xhtml+xml")
-        manifest.appendChild(x)
-
-    for i,image_filename in enumerate(image_filenames):
-        x = doc.createElement('item')
-        x.setAttribute('id',"image-{:05d}".format(i))
-        x.setAttribute('href', "images/{}".format(quote(image_filename)))
-        ext = Path(image_filename).suffix.lower()
-        if ext == '.gif':
-            x.setAttribute('media-type',"image/gif")
-        elif ext in ['.jpg', '.jpeg']:
-            x.setAttribute('media-type',"image/jpeg")
-        elif ext == '.png':
-            x.setAttribute('media-type',"image/png")
-        if image_filename==description_data["cover_image"]:
-            x.setAttribute('properties',"cover-image")
-
-            ## Ensure compatibility by also providing a meta tag in the metadata
-            y = doc.createElement('meta')
-            y.setAttribute('name',"cover")
-            y.setAttribute('content',"image-{:05d}".format(i))
-            metadata.appendChild(y)
-        manifest.appendChild(x)
-
-    for i,css_filename in enumerate(css_filenames):
-        x = doc.createElement('item')
-        x.setAttribute('id',"css-{:05d}".format(i))
-        x.setAttribute('href',"css/{}".format(css_filename))
-        x.setAttribute('media-type',"text/css")
-        manifest.appendChild(x)
-
-    ## Now building the spine
-
-    spine = doc.createElement('spine')
-    spine.setAttribute('toc', "ncx")
-
-    x = doc.createElement('itemref')
-    x.setAttribute('idref',"titlepage")
-    x.setAttribute('linear',"yes")
-    spine.appendChild(x)
-    for i,_ in enumerate(md_filenames):
-        x = doc.createElement('itemref')
-        x.setAttribute('idref',"s{:05d}".format(i))
-        x.setAttribute('linear',"yes")
-        spine.appendChild(x)
-
-    guide = doc.createElement('guide')
-    x = doc.createElement('reference')
-    x.setAttribute('type',"cover")
-    x.setAttribute('title',"Cover image")
-    x.setAttribute('href',"titlepage.xhtml")
-    guide.appendChild(x)
-
-
-    package.appendChild(metadata)
-    package.appendChild(manifest)
-    package.appendChild(spine)
-    package.appendChild(guide)
-    doc.appendChild(package)
-
-    return doc.toprettyxml()
-
-
-def get_container_XML():
-    container_data = """<?xml version="1.0" encoding="UTF-8" ?>\n"""
-    container_data += """<container version="1.0" xmlns="urn:oasis:names:tc:opendocument:xmlns:container">\n"""
-    container_data += """<rootfiles>\n"""
-    container_data += """<rootfile full-path="OPS/package.opf" media-type="application/oebps-package+xml"/>\n"""
-    container_data += """</rootfiles>\n</container>"""
-    return container_data
-
-def get_coverpage_XML(title, authors):
-    """Generate a simple cover page with title and optional author input."""
-    return f"""<?xml version="1.0" encoding="utf-8"?>
-<html xmlns="http://www.w3.org/1999/xhtml" xml:lang="en">
-<head>
-<title>Cover Page</title>
-<style type="text/css">
-body {{ 
-    margin: 0;
-    padding: 0;
-    height: 100vh;
-    display: flex;
-    justify-content: center;
-    align-items: center;
-    font-family: serif;
-}}
-.cover {{
-    padding: 3em;
-    text-align: center;
-    border: 1px solid #ccc;
-    max-width: 80%;
-}}
-h1 {{
-    font-size: 2em;
-    margin-bottom: 1em;
-    line-height: 1.2;
-    color: #333;
-}}
-p {{
-    font-size: 1.2em;
-    font-style: italic;
-    color: #666;
-    line-height: 1.4;
-}}
-</style>
-</head>
-<body>
-    <div class="cover">
-        <h1>{xml_escape(title)}</h1>
-        <p>{xml_escape(authors) if authors else ''}</p>
-    </div>
-</body>
-</html>"""
-
-def get_TOC_XML(default_css_filenames, markdown_filenames):
-    ## Returns the XML data for the TOC.xhtml file
-
-    toc_xhtml = """<?xml version="1.0" encoding="UTF-8"?>\n"""
-    toc_xhtml += """<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" lang="en">\n"""
-    toc_xhtml += """<head>\n<meta http-equiv="default-style" content="text/html; charset=utf-8"/>\n"""
-    toc_xhtml += """<title>Contents</title>\n"""
-
-    for css_filename in default_css_filenames:
-        toc_xhtml += """<link rel="stylesheet" href="css/{}" type="text/css"/>\n""".format(css_filename)
-
-    toc_xhtml += """</head>\n<body>\n"""
-    toc_xhtml += """<nav epub:type="toc" role="doc-toc" id="toc">\n<h2>Contents</h2>\n<ol epub:type="list">"""
-    for i,md_filename in enumerate(markdown_filenames):
-        stem = md_filename.split(".")[0]
-        href = quote("s{:05d}-{}.xhtml".format(i, stem))
-        toc_xhtml += """<li><a href="{}">{}</a></li>""".format(href, xml_escape(stem))
-    toc_xhtml += """</ol>\n</nav>\n</body>\n</html>"""
-
-    return toc_xhtml
-
-def get_TOCNCX_XML(markdown_filenames, uid="", title=""):
-    ## Returns the XML data for the TOC.ncx file
-
-    toc_ncx = """<?xml version="1.0" encoding="UTF-8"?>\n"""
-    toc_ncx += """<ncx xmlns="http://www.daisy.org/z3986/2005/ncx/" xml:lang="en" version="2005-1">\n"""
-    toc_ncx += """<head>\n"""
-    toc_ncx += """<meta name="dtb:uid" content="{}"/>\n""".format(xml_escape(uid))
-    toc_ncx += """<meta name="dtb:depth" content="1"/>\n"""
-    toc_ncx += """<meta name="dtb:totalPageCount" content="0"/>\n"""
-    toc_ncx += """<meta name="dtb:maxPageNumber" content="0"/>\n"""
-    toc_ncx += """</head>\n"""
-    toc_ncx += """<docTitle><text>{}</text></docTitle>\n""".format(xml_escape(title))
-    toc_ncx += """<navMap>\n"""
-    for i,md_filename in enumerate(markdown_filenames):
-        stem = md_filename.split(".")[0]
-        src = quote("s{:05d}-{}.xhtml".format(i, stem))
-        toc_ncx += """<navPoint id="navpoint-{}" playOrder="{}">\n""".format(i, i + 1)
-        toc_ncx += """<navLabel>\n<text>{}</text>\n</navLabel>""".format(xml_escape(stem))
-        toc_ncx += """<content src="{}"/>""".format(src)
-        toc_ncx += """ </navPoint>"""
-    toc_ncx += """</navMap>\n</ncx>"""
-
-    return toc_ncx
-
-def convert_math_to_mathml(html_text: str) -> str:
-    """Replace LaTeX math expressions in HTML with MathML, skipping code blocks."""
-    # Mask <pre>/<code> blocks so their $ delimiters are never treated as math
-    placeholders = {}
-    counter = [0]
-
-    def mask(m):
-        key = f"\x00MASK{counter[0]}\x00"
-        counter[0] += 1
-        placeholders[key] = m.group(0)
-        return key
-
-    masked = re.sub(r'<pre[\s\S]*?</pre>|<code[\s\S]*?</code>', mask, html_text, flags=re.DOTALL)
-
-    def try_convert(latex):
-        try:
-            return latex2mathml.converter.convert(latex)
-        except Exception:
-            return None
-
-    # Standalone display math that Markdown wrapped in <p>: replace the whole
-    # paragraph to avoid invalid XHTML like <p><div>...</div></p>
-    def replace_display_paragraph(m):
-        mathml = try_convert(m.group(1))
-        return f'<div class="math-display">{mathml}</div>' if mathml else m.group(0)
-
-    # Remaining $$...$$ (inside phrasing content): use <span> to stay valid
-    def replace_display_inline(m):
-        mathml = try_convert(m.group(1))
-        return f'<span class="math-display">{mathml}</span>' if mathml else m.group(0)
-
-    # Inline $...$
-    def replace_inline(m):
-        mathml = try_convert(m.group(1))
-        return f'<span class="math-inline">{mathml}</span>' if mathml else m.group(0)
-
-    masked = re.sub(r'<p>\s*\$\$(.*?)\$\$\s*</p>', replace_display_paragraph, masked, flags=re.DOTALL)
-    masked = re.sub(r'\$\$(.*?)\$\$', replace_display_inline, masked, flags=re.DOTALL)
-    masked = re.sub(r'(?<!\$)\$(?!\$)(.*?)(?<!\$)\$(?!\$)', replace_inline, masked, flags=re.DOTALL)
-
-    for key, original in placeholders.items():
-        masked = masked.replace(key, original)
-
-    return masked
-
-def get_chapter_XML(work_dir: str, md_filename: str, css_filenames: list[str], content: Optional[str] = None) -> tuple[str, list[str]]:
-    """
-    Convert markdown chapter to XHTML and process images.
-    Returns tuple of (XHTML content, list of images referenced in chapter)
-    
-    Args:
-        work_dir: Working directory containing markdown files
-        md_filename: Name of markdown file
-        css_filenames: List of CSS files to include
-        content: Optional pre-loaded markdown content. If None, content is read from file
-    """
-    work_dir_path = Path(work_dir)
-    
-    if content is None:
-        with open(work_dir_path / md_filename, "r", encoding="utf-8") as f:
-            markdown_data = f.read()
-    else:
-        markdown_data = content
-    
-    # Process markdown for images and get list of referenced images
-    markdown_data, chapter_images = process_markdown_for_images(markdown_data, work_dir_path)
-    
-    # Convert to HTML
-    html_text = markdown.markdown(
-        markdown_data,
-        extensions=["codehilite", "tables", "fenced_code", "footnotes"],
-        extension_configs={"codehilite": {"guess_lang": False}}
-    )
-
-    # Convert LaTeX math to MathML for EPUB readers
-    html_text = convert_math_to_mathml(html_text)
-
-    # Generate XHTML wrapper
-    xhtml = f"""<?xml version="1.0" encoding="UTF-8"?>
-<html xmlns="http://www.w3.org/1999/xhtml" xmlns:epub="http://www.idpf.org/2007/ops" xmlns:m="http://www.w3.org/1998/Math/MathML" lang="en">
-<head>
-    <meta http-equiv="default-style" content="text/html; charset=utf-8"/>
-    {''.join(f'<link rel="stylesheet" href="css/{css}" type="text/css" media="all"/>' for css in css_filenames)}
-</head>
-<body>
-{html_text}
-</body>
-</html>"""
-
-    return xhtml, chapter_images
-
-
-
-def convert_to_epub(markdown_dir: Path, output_path: Path) -> None:
-    """
-    Convert markdown files and images to EPUB format.
-    """
-    if not markdown_dir.exists():
-        raise FileNotFoundError(f"Markdown directory not found: {markdown_dir}")
-        
-    if not list(markdown_dir.glob('*.md')):
-        raise ValueError(f"No markdown files found in: {markdown_dir}")
-    
-    # Generate EPUB file
-    epub_path = markdown_dir / f"{markdown_dir.name}.epub"
-    main([str(markdown_dir), str(epub_path)])
-
-def main(args):
-    if len(args) < 2:
-        print("\nUsage:\n    python md2epub.py <markdown_directory> <output_file.epub>")
-        exit(1)
-
-    work_dir = args[0]
-    output_path = args[1]
-
-    images_dir = os.path.join(work_dir, 'images/')
-    css_dir = os.path.join(work_dir, 'css/')
-
-    try:
-        # Reading/Creating the JSON file containing the description of the eBook
-        description_path = os.path.join(work_dir, "description.json")
-        existing_metadata = {}
-        
-        if os.path.exists(description_path):
-            with open(description_path, 'r', encoding='utf-8') as f:
-                existing_metadata = json.load(f)
-        
-        # Get metadata from user
-        json_data = get_metadata_from_user(existing_metadata)
-        
-        # Find all markdown files if not already in metadata
-        if not json_data["chapters"]:
-            markdown_files = [f for f in os.listdir(work_dir) if f.endswith('.md')]
-            for md_file in sorted(markdown_files):
-                json_data["chapters"].append({
-                    "markdown": md_file,
-                    "css": ""
-                })
-        
-        # Save the updated description.json
-        with open(description_path, 'w', encoding='utf-8') as f:
-            json.dump(json_data, f, indent=2)
-        
-        # Review markdown files and store updated content
-        chapter_contents = {}
-        for chapter in json_data["chapters"]:
-            md_path = Path(work_dir) / chapter["markdown"]
-            should_continue, content = review_markdown(md_path)
-            if not should_continue:
-                print("\nConversion aborted by user.")
-                return
-            chapter_contents[chapter["markdown"]] = content
-
-        # Get title and author
-        title = json_data["metadata"].get("dc:title", "Untitled Document")
-        authors = json_data["metadata"].get("dc:creator", None)
-
-        # Compile list of files
-        all_md_filenames = []
-        all_css_filenames = json_data["default_css"][:]
-        for chapter in json_data["chapters"]:
-            if chapter["markdown"] not in all_md_filenames:
-                all_md_filenames.append(chapter["markdown"])
-            if len(chapter["css"]) and (chapter["css"] not in all_css_filenames):
-                all_css_filenames.append(chapter["css"])
-        
-        all_image_filenames = get_all_filenames(images_dir, extensions=["gif", "jpg", "jpeg", "png"])
-
-        # First process all chapters and images
-        images_dir = Path(work_dir) / 'images'
-        epub_images_dir = Path(work_dir) / 'epub_images'
-        processed_images = {}  # Store processed image data
-        all_referenced_images = set()
-        chapter_data = {}  # Store processed chapter data
-
-        # First pass: Process chapters and collect image references
-        print("\nProcessing chapters and collecting image references...")
-        for i, chapter in enumerate(json_data["chapters"]):
-            css_files = json_data["default_css"][:]
-            if chapter["css"]:
-                css_files.append(chapter["css"])
-                
-            # Process chapter content
-            chapter_xhtml, chapter_images = get_chapter_XML(
-                work_dir, 
-                chapter["markdown"], 
-                css_files,
-                content=chapter_contents[chapter["markdown"]]
-            )
-            chapter_data[chapter["markdown"]] = chapter_xhtml
-            all_referenced_images.update(chapter_images)
-
-        # Process and optimize images
-        print("\nProcessing and optimizing images...")
-        if images_dir.exists() and all_referenced_images:
-            epub_images_dir.mkdir(exist_ok=True)
-            
-            for image in all_referenced_images:
-                src_path = images_dir / image
-                if src_path.exists():
-                    try:
-                        dest_path = epub_images_dir / image
-                        copy_and_optimize_image(src_path, dest_path)
-                        
-                        # Store processed image data
-                        with open(dest_path, "rb") as f:
-                            processed_images[image] = f.read()
-                    except Exception as e:
-                        print(f"Warning: Failed to process image {image}: {e}")
-                else:
-                    print(f"Warning: Referenced image not found: {src_path}")
-            
-            # Cleanup temporary directory
-            import shutil
-            shutil.rmtree(epub_images_dir, ignore_errors=True)
-
-        # Now create the EPUB file with all prepared content
-        print("\nCreating EPUB file...")
-        with zipfile.ZipFile(output_path, "w") as epub:
-            # Write mimetype (must be first and uncompressed)
-            epub.writestr("mimetype", "application/epub+zip")
-
-            # Write container.xml
-            epub.writestr("META-INF/container.xml", get_container_XML(), zipfile.ZIP_DEFLATED)
-
-            # Write package.opf
-            epub.writestr("OPS/package.opf", 
-                get_packageOPF_XML(
-                    md_filenames=all_md_filenames,
-                    image_filenames=all_image_filenames,
-                    css_filenames=all_css_filenames,
-                    description_data=json_data
-                ), 
-                zipfile.ZIP_DEFLATED
-            )
-
-            # Write cover page
-            coverpage_data = get_coverpage_XML(title, authors)
-            epub.writestr("OPS/titlepage.xhtml", coverpage_data.encode('utf-8'), zipfile.ZIP_DEFLATED)
-
-            # Write processed chapters
-            print("Writing chapters...")
-            for i, chapter in enumerate(json_data["chapters"]):
-                print(f"  Writing chapter {i+1}/{len(json_data['chapters'])}: {chapter['markdown']}")
-                epub.writestr(
-                    f"OPS/s{i:05d}-{chapter['markdown'].split('.')[0]}.xhtml",
-                    chapter_data[chapter["markdown"]].encode('utf-8'),
-                    zipfile.ZIP_DEFLATED
-                )
-
-            # Write processed images
-            if processed_images:
-                print(f"Writing {len(processed_images)} processed images...")
-                for image_name, image_data in processed_images.items():
-                    epub.writestr(f"OPS/images/{image_name}", image_data, zipfile.ZIP_DEFLATED)
-
-            # Write TOC files
-            print("Writing table of contents...")
-            epub.writestr("OPS/TOC.xhtml", 
-                get_TOC_XML(json_data["default_css"], all_md_filenames),
-                zipfile.ZIP_DEFLATED
-            )
-            
-            epub.writestr("OPS/toc.ncx",
-                get_TOCNCX_XML(
-                    all_md_filenames,
-                    uid=json_data["metadata"].get("dc:identifier", ""),
-                    title=json_data["metadata"].get("dc:title", "")
-                ),
-                zipfile.ZIP_DEFLATED
-            )
-
-            # Copy remaining images that weren't referenced in markdown
-            remaining_images = set(all_image_filenames) - set(processed_images.keys())
-            if remaining_images and os.path.exists(images_dir):
-                print(f"Writing {len(remaining_images)} additional images...")
-                for image in remaining_images:
-                    with open(os.path.join(images_dir, image), "rb") as f:
-                        epub.writestr(f"OPS/images/{image}", f.read(), zipfile.ZIP_DEFLATED)
-
-            # Copy CSS files; write a default style.css for any that are missing
-            default_css_content = b"""body { font-family: serif; line-height: 1.5; margin: 5%; }
-h1, h2, h3, h4, h5, h6 { font-family: sans-serif; }
-img { max-width: 100%; height: auto; }
-pre, code { font-family: monospace; font-size: 0.9em; }
-"""
-            print(f"Writing {len(all_css_filenames)} CSS files...")
-            for css in all_css_filenames:
-                css_path = os.path.join(css_dir, css)
-                if os.path.exists(css_path):
-                    with open(css_path, "rb") as f:
-                        epub.writestr(f"OPS/css/{css}", f.read(), zipfile.ZIP_DEFLATED)
-                else:
-                    epub.writestr(f"OPS/css/{css}", default_css_content, zipfile.ZIP_DEFLATED)
-
-        print(f"\nEPUB creation complete: {output_path}")
-        
-    except Exception:
-        import traceback
-        print(f"Error processing {work_dir}:")
-        print(traceback.format_exc())
-        raise
-
-if __name__ == "__main__":
-    main(sys.argv[1:])