2654400439/Paper2Seminar / skills/paper-ppt-orchestrator
paper-ppt-orchestrator
VerifiedBuild 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.
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())
Related skills
| Skill | Stars | Updated | Works with | Status | Install |
|---|---|---|---|---|---|
| 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: 472k | Updated | Claude CodeCodex | Verified | Install |
| 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: 472k | Updated | Claude CodeCodex | Verified | Install |
| rea-tool-designmorluto/reaAudit, investigate, design, or change REA investigation tools, CLI/MCP contracts, provider capabilities, and Evidence semantics. | Stars: 472k | Updated | Claude CodeCodex | Verified | Install |
| ponytail-auditDietrichGebert/ponytailQuality audit of the whole repo: bugs, security, real load, missing tests, speed, and what to delete. Most important first. | Stars: 196k | Updated | Claude CodeCodex | Verified | Install |