Skip to content

2654400439/Paper2Seminar / skills/paper-ppt-orchestrator

paper-ppt-orchestrator

Verified

Build complete fixed-layout academic-paper presentations from a PDF with bundled PPTX and one-page HTML templates. Use for full paper reading, complexity-aware slide budgeting, subsection coverage mapping, figure extraction, TikZ or Matplotlib evidence visuals, deterministic PPTX assembly, and final QA. Trigger for requests to turn a paper PDF into a discussion-group deck, especially 12-16+ page systems, security, networking, or measurement papers.

FileKindSize
SKILL.mdskill md17.9 KB
agents/openai.yamlconfig296 B
assets/one-page-summary.htmlother7.8 KB
assets/seminar-template.pptxbinary572.7 KB
references/content-design.mdmarkdown5.7 KB
references/data-viz.schema.jsonconfig2.9 KB
references/deck-plan.schema.jsonconfig8.5 KB
references/deck-sizing.mdmarkdown3.4 KB
references/environment-compatibility.mdmarkdown2.8 KB
references/feature-registry.jsonconfig1.4 KB
references/figure-extraction.mdmarkdown5.1 KB
references/job-request.defaults.jsonconfig1.6 KB
references/job-request.schema.jsonconfig7.5 KB
references/one-page-template.mdmarkdown3.1 KB
references/qa-gates.mdmarkdown10.0 KB
references/speaker-notes.mdmarkdown3.1 KB
references/template-contract.mdmarkdown5.1 KB
references/tikz-layout.mdmarkdown12.2 KB
references/visual-selection.mdmarkdown6.5 KB
references/workflow.mdmarkdown9.8 KB
requirements-doclayout.txtmarkdown238 B
requirements-ui.txtmarkdown39 B
requirements.txtmanifest68 B
scripts/apply_speaker_notes.pyscript6.1 KB
scripts/build_ppt.pyscript16.3 KB
scripts/crop_author_block.pyscript7.9 KB
scripts/crop_image_region.pyscript2.4 KB
scripts/export_pptx_pages.ps1script1.3 KB
scripts/extract_paper_assets.pyscript22.3 KB
scripts/job_request.pyscript17.1 KB
scripts/make_contact_sheet.pyscript4.0 KB
scripts/paper_ppt.pyscript17.1 KB
scripts/preflight_capabilities.pyscript8.3 KB
scripts/render_data_viz.pyscript14.6 KB
scripts/render_deck_overview.pyscript2.4 KB
scripts/render_one_page_html.pyscript13.4 KB
scripts/render_readability.pyscript4.1 KB
scripts/update_qa_status.pyscript10.1 KB
scripts/validate_deck_plan.pyscript33.9 KB
webapp/__init__.pyscript49 B
webapp/backend.pyscript14.5 KB
webapp/job_runner.pyscript3.2 KB
webapp/streamlit_app.pyscript17.3 KB

scripts/paper_ppt.py

View on GitHub
#!/usr/bin/env python3
"""Command-line entry point for the paper-PPT prototype pipeline."""

from __future__ import annotations

import argparse
import json
import subprocess
import sys
from pathlib import Path

from extract_paper_assets import default_model_path, download_model


SCRIPT_DIR = Path(__file__).resolve().parent


def run(command: list[str]) -> None:
    completed = subprocess.run(command, check=False)
    if completed.returncode != 0:
        raise SystemExit(completed.returncode)


def resolve_from(base: Path, value: str) -> Path:
    path = Path(value)
    return path.resolve() if path.is_absolute() else (base / path).resolve()


def render_planned_data(plan_path: Path) -> None:
    plan = json.loads(plan_path.read_text(encoding="utf-8"))
    base = plan_path.parent
    for slide in plan.get("slides", []):
        visual = slide.get("visual", {})
        if visual.get("mode") != "data_redraw":
            continue
        spec = resolve_from(base, visual["data_spec_ref"])
        output = resolve_from(base, visual["asset_ref"])
        run([sys.executable, str(SCRIPT_DIR / "render_data_viz.py"), str(spec), "-o", str(output)])


def ensure_author_visual(plan_path: Path) -> None:
    plan = json.loads(plan_path.read_text(encoding="utf-8"))
    base = plan_path.parent
    project = plan["project"]
    output = resolve_from(base, project["author_visual"])
    if output.is_file():
        return
    paper_pdf = resolve_from(base, project["paper_pdf"])
    run(
        [
            sys.executable,
            str(SCRIPT_DIR / "crop_author_block.py"),
            str(paper_pdf),
            "-o",
            str(output),
            "--title",
            str(plan["paper"]["title_en"]),
        ]
    )


def plan_output(plan_path: Path) -> Path:
    plan = json.loads(plan_path.read_text(encoding="utf-8"))
    return resolve_from(plan_path.parent, plan["project"]["output_pptx"])


def plan_readability_mode(plan_path: Path) -> str:
    plan = json.loads(plan_path.read_text(encoding="utf-8"))
    return plan.get("project", {}).get("final_readability_mode", "off")


def plan_readability_output_dir(plan_path: Path) -> Path:
    plan = json.loads(plan_path.read_text(encoding="utf-8"))
    manifest = plan.get("project", {}).get(
        "readability_manifest", "qa/readability/manifest.json"
    )
    return resolve_from(plan_path.parent, manifest).parent


def main() -> int:
    parser = argparse.ArgumentParser(description=__doc__)
    subparsers = parser.add_subparsers(dest="command", required=True)

    validate = subparsers.add_parser("validate", help="validate deck-plan.json")
    validate.add_argument("plan", type=Path)
    validate.add_argument("--stage", choices=("plan", "assembly", "notes", "final"), default="plan")

    job_request = subparsers.add_parser(
        "job-request", help="compile or validate a provider-neutral job request"
    )
    job_request.add_argument("job_request_args", nargs=argparse.REMAINDER)

    preflight = subparsers.add_parser("preflight", help="record host and agent-visible capabilities")
    preflight.add_argument("-o", "--output", type=Path)
    preflight.add_argument("--imagegen", choices=("available", "unavailable", "unknown"), default="unknown")
    preflight.add_argument("--web-search", choices=("available", "unavailable", "unknown"), default="unknown")

    data = subparsers.add_parser("render-data", help="render one PaperEvidenceViz spec")
    data.add_argument("spec", type=Path)
    data.add_argument("-o", "--output", type=Path)

    one_page = subparsers.add_parser("render-one-page-html", help="render a filled one-page HTML file")
    one_page.add_argument("html", type=Path)
    one_page.add_argument("-o", "--output", type=Path, required=True)
    one_page.add_argument("--browser", type=Path)
    one_page.add_argument("--temp-dir", type=Path)
    one_page.add_argument("--timeout", type=int, default=30)
    one_page.add_argument("--allow-no-sandbox", action="store_true")

    crop_image = subparsers.add_parser("crop-image", help="create a focused crop from an extracted raster asset")
    crop_image.add_argument("input", type=Path)
    crop_image.add_argument("-o", "--output", type=Path, required=True)
    crop_image.add_argument("--bbox", required=True, help="normalized x0,y0,x1,y1")
    crop_image.add_argument("--source-label", default="")

    authors = subparsers.add_parser("crop-authors", help="crop paper authors and affiliations")
    authors.add_argument("pdf", type=Path)
    authors.add_argument("-o", "--output", type=Path, required=True)
    authors.add_argument("--page", type=int, default=1)
    authors.add_argument("--title", default="")
    authors.add_argument("--dpi", type=int, default=260)
    authors.add_argument("--bbox", help="manual x0,y0,x1,y1 override in PDF points")

    extract = subparsers.add_parser(
        "extract-assets", help="extract paper figures and tables with DocLayout or CaptionCrop"
    )
    extract.add_argument("pdf", type=Path)
    extract.add_argument("-o", "--output", type=Path, required=True)
    extract.add_argument("--backend", choices=("doclayout", "captioncrop"), default="doclayout")
    extract.add_argument("--clean", action="store_true")
    extract.add_argument("--model", type=Path)
    extract.add_argument("--cache-dir", type=Path)
    extract.add_argument("--allow-unverified-model", action="store_true")
    extract.add_argument("--confidence", type=float, default=0.18)
    extract.add_argument("--image-size", type=int, default=1024)
    extract.add_argument("--detection-dpi", type=int, default=144)
    extract.add_argument("--crop-dpi", type=int, default=300)
    extract.add_argument("--padding-points", type=float, default=5.0)
    extract.add_argument("--dedupe-iou", type=float, default=0.75)
    extract.add_argument("--device", default="cpu")
    extract.add_argument("--captioncrop-command", type=Path)
    extract.add_argument("--captioncrop-dpi", type=int, default=240)

    model = subparsers.add_parser(
        "download-layout-model", help="download and verify the pinned DocLayout model"
    )
    model.add_argument("-o", "--output", type=Path)
    model.add_argument("--force", action="store_true")

    build = subparsers.add_parser("build", help="build PPTX from a prepared plan")
    build.add_argument("plan", type=Path)
    build.add_argument("-o", "--output", type=Path)

    notes = subparsers.add_parser(
        "apply-notes", help="apply post-QA per-slide speaker scripts to an existing PPTX"
    )
    notes.add_argument("plan", type=Path)
    notes.add_argument("--pptx", type=Path)

    for qa_action in ("approve-assets", "approve-slides"):
        qa = subparsers.add_parser(qa_action, help=f"apply audited {qa_action} QA transition")
        qa.add_argument("plan", type=Path)
        selection = qa.add_mutually_exclusive_group(required=True)
        selection.add_argument("--slides", nargs="+")
        selection.add_argument("--all-content", action="store_true")
        qa.add_argument("--note", default="")
        qa.add_argument("--actor")
        qa.add_argument("--log", type=Path)
        if qa_action == "approve-slides":
            qa.add_argument("--readability-mode", choices=("off", "overview", "full"))
            qa.add_argument("--readability-manifest", type=Path)

    execute = subparsers.add_parser("run", help="render planned data assets, build PPTX, optionally create overview")
    execute.add_argument("plan", type=Path)
    execute.add_argument("--overview", action="store_true")
    execute.add_argument("--overview-output", type=Path)
    execute.add_argument("--readability-mode", choices=("off", "overview", "full"))
    execute.add_argument("--readability-output-dir", type=Path)
    execute.add_argument("--readability-group-size", type=int, default=4)

    overview = subparsers.add_parser("overview", help="render a PPTX to one overview PNG")
    overview.add_argument("pptx", type=Path)
    overview.add_argument("-o", "--output", type=Path, required=True)
    overview.add_argument("--columns", type=int, default=0)
    overview.add_argument("--thumb-width", type=int, default=720)

    readability = subparsers.add_parser(
        "readability", help="create an optional final-size readability review package"
    )
    readability.add_argument("--mode", choices=("off", "overview", "full"), default="off")
    source = readability.add_mutually_exclusive_group()
    source.add_argument("--pptx", type=Path)
    source.add_argument("--slides-dir", type=Path)
    readability.add_argument("-o", "--output-dir", type=Path, required=True)
    readability.add_argument("--dpi", type=int, default=120)
    readability.add_argument("--group-size", type=int, default=4)

    args = parser.parse_args()
    if args.command == "validate":
        run(
            [
                sys.executable,
                str(SCRIPT_DIR / "validate_deck_plan.py"),
                str(args.plan.resolve()),
                "--stage",
                args.stage,
            ]
        )
    elif args.command == "job-request":
        if not args.job_request_args:
            raise SystemExit("job-request requires: defaults, init, brief, confirm, or validate")
        run(
            [
                sys.executable,
                str(SCRIPT_DIR / "job_request.py"),
                *args.job_request_args,
            ]
        )
    elif args.command == "preflight":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "preflight_capabilities.py"),
            "--imagegen",
            args.imagegen,
            "--web-search",
            args.web_search,
        ]
        if args.output:
            command += ["-o", str(args.output.resolve())]
        run(command)
    elif args.command == "render-data":
        command = [sys.executable, str(SCRIPT_DIR / "render_data_viz.py"), str(args.spec.resolve())]
        if args.output:
            command += ["-o", str(args.output.resolve())]
        run(command)
    elif args.command == "render-one-page-html":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "render_one_page_html.py"),
            str(args.html.resolve()),
            "-o",
            str(args.output.resolve()),
        ]
        if args.browser:
            command += ["--browser", str(args.browser.resolve())]
        if args.temp_dir:
            command += ["--temp-dir", str(args.temp_dir.resolve())]
        command += ["--timeout", str(args.timeout)]
        if args.allow_no_sandbox:
            command += ["--allow-no-sandbox"]
        run(command)
    elif args.command == "crop-image":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "crop_image_region.py"),
            str(args.input.resolve()),
            "-o",
            str(args.output.resolve()),
            "--bbox",
            args.bbox,
        ]
        if args.source_label:
            command += ["--source-label", args.source_label]
        run(command)
    elif args.command == "crop-authors":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "crop_author_block.py"),
            str(args.pdf.resolve()),
            "-o",
            str(args.output.resolve()),
            "--page",
            str(args.page),
            "--dpi",
            str(args.dpi),
        ]
        if args.title:
            command += ["--title", args.title]
        if args.bbox:
            command += ["--bbox", args.bbox]
        run(command)
    elif args.command == "extract-assets":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "extract_paper_assets.py"),
            str(args.pdf.resolve()),
            "-o",
            str(args.output.resolve()),
            "--backend",
            args.backend,
        ]
        if args.clean:
            command.append("--clean")
        if args.model:
            command += ["--model", str(args.model.resolve())]
        if args.cache_dir:
            command += ["--cache-dir", str(args.cache_dir.resolve())]
        if args.allow_unverified_model:
            command.append("--allow-unverified-model")
        command += [
            "--confidence", str(args.confidence),
            "--image-size", str(args.image_size),
            "--detection-dpi", str(args.detection_dpi),
            "--crop-dpi", str(args.crop_dpi),
            "--padding-points", str(args.padding_points),
            "--dedupe-iou", str(args.dedupe_iou),
            "--device", args.device,
            "--captioncrop-dpi", str(args.captioncrop_dpi),
        ]
        if args.captioncrop_command:
            command += ["--captioncrop-command", str(args.captioncrop_command.resolve())]
        run(command)
    elif args.command == "download-layout-model":
        output = (args.output or default_model_path()).expanduser().resolve()
        try:
            result = download_model(output, force=args.force)
        except RuntimeError as exc:
            print(f"ERROR: {exc}", file=sys.stderr)
            return 1
        action = "Downloaded" if result["downloaded"] else "Verified existing"
        print(f"{action} DocLayout model: {result['path']}")
        print(f"SHA-256: {result['sha256']}")
    elif args.command == "build":
        command = [sys.executable, str(SCRIPT_DIR / "build_ppt.py"), str(args.plan.resolve())]
        if args.output:
            command += ["-o", str(args.output.resolve())]
        run(command)
    elif args.command == "apply-notes":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "apply_speaker_notes.py"),
            str(args.plan.resolve()),
        ]
        if args.pptx:
            command += ["--pptx", str(args.pptx.resolve())]
        run(command)
    elif args.command in {"approve-assets", "approve-slides"}:
        command = [
            sys.executable,
            str(SCRIPT_DIR / "update_qa_status.py"),
            args.command,
            str(args.plan.resolve()),
        ]
        if args.slides:
            command += ["--slides", *args.slides]
        else:
            command += ["--all-content"]
        if args.note:
            command += ["--note", args.note]
        if args.actor:
            command += ["--actor", args.actor]
        if args.log:
            command += ["--log", str(args.log.resolve())]
        if args.command == "approve-slides":
            if args.readability_mode:
                command += ["--readability-mode", args.readability_mode]
            if args.readability_manifest:
                command += [
                    "--readability-manifest",
                    str(args.readability_manifest.resolve()),
                ]
        run(command)
    elif args.command == "overview":
        run(
            [
                sys.executable,
                str(SCRIPT_DIR / "render_deck_overview.py"),
                "--pptx",
                str(args.pptx.resolve()),
                "-o",
                str(args.output.resolve()),
                "--columns",
                str(args.columns),
                "--thumb-width",
                str(args.thumb_width),
            ]
        )
    elif args.command == "readability":
        command = [
            sys.executable,
            str(SCRIPT_DIR / "render_readability.py"),
            "--mode",
            args.mode,
            "-o",
            str(args.output_dir.resolve()),
            "--dpi",
            str(args.dpi),
            "--group-size",
            str(args.group_size),
        ]
        if args.pptx:
            command += ["--pptx", str(args.pptx.resolve())]
        if args.slides_dir:
            command += ["--slides-dir", str(args.slides_dir.resolve())]
        run(command)
    else:
        plan = args.plan.resolve()
        readability_mode = args.readability_mode or plan_readability_mode(plan)
        if args.overview and readability_mode != "off":
            raise SystemExit(
                "--overview and --readability-mode cannot be combined; use readability mode overview"
            )
        ensure_author_visual(plan)
        render_planned_data(plan)
        run([sys.executable, str(SCRIPT_DIR / "build_ppt.py"), str(plan)])
        if args.overview:
            pptx = plan_output(plan)
            overview_output = args.overview_output or pptx.with_suffix(".overview.png")
            run(
                [
                    sys.executable,
                    str(SCRIPT_DIR / "render_deck_overview.py"),
                    "--pptx",
                    str(pptx),
                    "-o",
                    str(overview_output.resolve()),
                ]
            )
        elif readability_mode != "off":
            readability_output = (
                args.readability_output_dir.resolve()
                if args.readability_output_dir
                else plan_readability_output_dir(plan)
            )
            run(
                [
                    sys.executable,
                    str(SCRIPT_DIR / "render_readability.py"),
                    "--mode",
                    readability_mode,
                    "--pptx",
                    str(plan_output(plan)),
                    "-o",
                    str(readability_output),
                    "--group-size",
                    str(args.readability_group_size),
                ]
            )
    return 0


if __name__ == "__main__":
    raise SystemExit(main())
rea-analysis-optimizationmorluto/reaOptimize REA providers and shared analysis workflows for agent context, latency, CPU, and memory while preserving correctness and Evidence. Use for analysis bottlenecks and cache or query design; CI/test-suite optimization belongs to rea-ci-tests-audit.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-ci-tests-auditmorluto/reaAudit REA CI and test suites for correctness, fixture drift, false passes, and measured performance; use for suite or workflow investigations and efficiency changes, rather than ordinary feature testing or a single test failure.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics.Stars: 472kUpdated Claude CodeCodexVerifiedInstall
ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first.Stars: 196kUpdated Claude CodeCodexVerifiedInstall