Python Ebook Automation in 2026: The Complete Stack for Solo Developers

#!/usr/bin/env python3
"""
ebook_orchestrator.py — Full pipeline: generate → validate → compile → publish
"""
import json
import subprocess
import sys
from pathlib import Path
import anthropic
import requests

CHECKPOINT = Path("checkpoint.json")
GUMROAD_TOKEN = "your_gumroad_token"
PRODUCT_ID = "xhxkzz"

def load_state() -> dict:
    if CHECKPOINT.exists():
        return json.loads(CHECKPOINT.read_text())
    return {"stage": "init", "chapters": {}}

def save_state(state: dict):
    CHECKPOINT.write_text(json.dumps(state, indent=2))

# --- Layer 1: Generation ---
def generate_chapter(client: anthropic.Anthropic, title: str, outline: str) -> str:
    print(f"  Generating: {title}")
    message = client.messages.create(
        model="claude-opus-4-5",
        max_tokens=4096,
        messages=[{
            "role": "user",
            "content": (
                f"Write a technical ebook chapter titled '{title}'.\n"
                f"Outline:\n{outline}\n\n"
                "Requirements: Python code examples, no filler, ~1200 words."
            )
        }]
    )
    return message.content[0].text

# --- Layer 2: Validation ---
def validate_chapter(content: str, chapter_path: Path) -> bool:
    chapter_path.write_text(content)
    # Extract and AST-check all Python fences
    import ast, re
    blocks = re.findall(r"```

python\n(.*?)

```", content, re.DOTALL)
    for i, block in enumerate(blocks):
        try:
            ast.parse(block)
        except SyntaxError as e:
            print(f"  SyntaxError in block {i}: {e}")
            return False
    print(f"  Validated {len(blocks)} code block(s)")
    return True

# --- Layer 3: Compilation ---
def compile_epub(chapters_dir: Path, output_path: Path, metadata: dict) -> Path:
    chapter_files = sorted(chapters_dir.glob("ch*.md"))
    cmd = [
        "pandoc",
        "--from", "markdown",
        "--to", "epub3",
        "--metadata", f"title={metadata['title']}",
        "--metadata", f"author={metadata['author']}",
        "--epub-cover-image", metadata["cover"],
        "-o", str(output_path),
        *[str(f) for f in chapter_files]
    ]
    result = subprocess.run(cmd, capture_output=True, text=True)
    if result.returncode != 0:
        raise RuntimeError(f"Pandoc failed: {result.stderr}")
    print(f"  EPUB compiled: {output_path} ({output_path.stat().st_size // 1024} KB)")
    return output_path

# --- Layer 4: Distribution ---
def update_gumroad_product(epub_path: Path, price_cents: int = 1299) -> dict:
    url = f"https://api.gumroad.com/v2/products/{PRODUCT_ID}"
    with open(epub_path, "rb") as f:
        response = requests.post(url, data={
            "access_token": GUMROAD_TOKEN,
            "price": price_cents,
            "name": "Python Ebook Automation Pipeline",
        }, files={"url": f})
    response.raise_for_status()
    return response.json()

# --- Main Orchestrator ---
def run_pipeline(outlines: list[dict], metadata: dict):
    client = anthropic.Anthropic()
    state = load_state()
    chapters_dir = Path("chapters")
    chapters_dir.mkdir(exist_ok=True)

    # Stage 1: Generate & validate
    if state["stage"] in ("init", "generating"):
        state["stage"] = "generating"
        for item in outlines:
            key = item["title"]
            if key in state["chapters"]:
                print(f"  Skipping (cached): {key}")
                continue
            content = generate_chapter(client, item["title"], item["outline"])
            path = chapters_dir / item["filename"]
            if validate_chapter(content, path):
                state["chapters"][key] = str(path)
                save_state(state)
            else:
                print(f"  Validation failed for {key}. Fix and re-run.")
                sys.exit(1)
        state["stage"] = "compiling"
        save_state(state)

    # Stage 2: Compile
    if state["stage"] == "compiling":
        epub = compile_epub(chapters_dir, Path("book.epub"), metadata)
        state["stage"] = "publishing"
        state["epub"] = str(epub)
        save_state(state)

    # Stage 3: Publish
    if state["stage"] == "publishing":
        result = update_gumroad_product(Path(state["epub"]))
        print(f"  Published: {result['product']['short_url']}")
        state["stage"] = "done"
        save_state(state)

    print("Pipeline complete.")

if __name__ == "__main__":
    outlines = [
        {
            "title": "Setting Up the Generation Pipeline",
            "filename": "ch01.md",
            "outline": "Claude API auth, prompt structure, streaming vs batch"
        },
        {
            "title": "Code Validation with AST",
            "filename": "ch02.md",
            "outline": "ast.parse, extracting fences, subprocess test runner"
        },
    ]
    metadata = {
        "title": "Python Ebook Automation",
        "author": "Your Name",
        "cover": "cover.jpg"
    }
    run_pipeline(outlines, metadata)