Michael StanglandClaude Opus 4.8
e7aa3b4e4b
Skripte zum Befuellen der Kapitelstruktur aus dem Fortna-Rohmaterial und Aufbau eines vollstaendigen Sphinx/LaTeX-Builds (nur Code/Config/Doku, generierte RST/Bilder/PDFs und Rohmaterial via .gitignore ausgeschlossen). - lib/fortna_inventory.py: Rohmaterial scannen, Sprache+Zielkapitel+Aktion zuordnen, results/fortna_inventory.json schreiben - lib/fortna_convert_chapters.py: 5 Hauptanleitungen volltextig (Text+Bilder) konvertieren, Verzeichnislisten (index.de.rst) fuer uebrige Kapitel - lib/fortna_init_project.py: projekte/fortna/ (anlage.json, overrides, images) - lib/build_index.py: index.rst mit toctrees aus chapters/**/*.de.rst generieren - lib/extract_products.py: Symbolfont-Zeichen (PUA) auf Unicode mappen (clean_pua) - conf.py: Sphinx-Build (lualatex, babel statt polyglossia, iconpackage=none) - bin/: .bat/.sh-Wrapper fuer alle Skripte + build_pdf - doc/: Konzept-Plan (plan_fortna_extraktion.md) und lib-Skript-Uebersicht - requirements.txt: Sphinx + myst-parser ergaenzt Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
282 lines
11 KiB
Python
282 lines
11 KiB
Python
"""Befuellt chapters/ aus dem Fortna-Rohmaterial anhand des Inventars.
|
|
|
|
Zwei Aktionsarten (siehe doc/plan_fortna_extraktion.md):
|
|
|
|
- action="convert": Die 5 Hauptanleitungen (Betriebs-/Wartungsanleitung,
|
|
Funktionsbeschreibung ILS/OMNIFLO/LoadingLoop) werden volltextig mit Bildern
|
|
nach .rst konvertiert. Genutzt wird die positionsbasierte Extraktion aus
|
|
extract_products.py (Kopf-/Fusszeilen-Filter, Schriftgroessen-Heuristik),
|
|
die fuer Word-erstellte PDFs robuster ist als die pdfminer-Variante.
|
|
|
|
- action="list": Alle uebrigen Kapitel (Zertifikate, Layouts, Schaltplaene,
|
|
Notstopp/Bereichsstopp, Pruefberichte, Ersatzteile, Lieferantendoku) erhalten
|
|
eine generierte index.de.rst mit einer RST-list-table (Dateiname, Kategorie,
|
|
Groesse, Originalpfad). Es werden KEINE PDFs kopiert.
|
|
|
|
Nur deutschsprachige Quellen (lang == "de") werden verarbeitet.
|
|
|
|
Verwendung:
|
|
python fortna_convert_chapters.py --dry-run
|
|
python fortna_convert_chapters.py --apply
|
|
python fortna_convert_chapters.py --apply --only convert
|
|
python fortna_convert_chapters.py --apply --only list
|
|
"""
|
|
|
|
from __future__ import annotations
|
|
|
|
import argparse
|
|
import json
|
|
import logging
|
|
import os
|
|
import re
|
|
import shutil
|
|
import sys
|
|
from collections import defaultdict
|
|
from pathlib import Path
|
|
|
|
# extract_products stellt die robuste PDF-Extraktion bereit (gleiches lib/-Verzeichnis)
|
|
import extract_products as ep
|
|
|
|
log = logging.getLogger(__name__)
|
|
|
|
RST_H = {1: "=", 2: "-", 3: "~", 4: "^"}
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Hilfen
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def slugify(name: str) -> str:
|
|
"""Erzeugt einen sauberen Dateinamen-Stamm aus einem PDF-Namen."""
|
|
stem = Path(name).stem.lower()
|
|
stem = re.sub(r"[^a-z0-9]+", "_", stem)
|
|
stem = re.sub(r"_+", "_", stem).strip("_")
|
|
return stem
|
|
|
|
|
|
def rst_heading(text: str, level: int = 1) -> list[str]:
|
|
"""Erzeugt eine RST-Ueberschrift als Zeilenliste."""
|
|
char = RST_H[level]
|
|
lines = []
|
|
if level == 1:
|
|
lines.append(char * max(len(text), 3))
|
|
lines.append(text)
|
|
lines.append(char * max(len(text), 3))
|
|
lines.append("")
|
|
return lines
|
|
|
|
|
|
def load_inventory(path: Path) -> dict:
|
|
with open(path, encoding="utf-8") as f:
|
|
return json.load(f)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# action="convert": Volltext + Bilder
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def convert_manual(item: dict, source_root: Path, chapters_dir: Path,
|
|
dry_run: bool) -> None:
|
|
"""Konvertiert eine Hauptanleitung nach chapters/<kapitel>/."""
|
|
src_pdf = source_root / item["rel_path"]
|
|
chapter_dir = chapters_dir / item["chapter"]
|
|
stem = slugify(item["filename"])
|
|
rst_path = chapter_dir / f"{stem}.de.rst"
|
|
img_dir = chapter_dir / "images"
|
|
|
|
log.info("CONVERT %s", item["chapter"])
|
|
log.info(" Quelle: %s (%d MB)", item["rel_path"],
|
|
item["size_bytes"] // (1024 * 1024))
|
|
log.info(" -> %s", rst_path.relative_to(chapters_dir))
|
|
|
|
if dry_run:
|
|
return
|
|
|
|
if not src_pdf.exists():
|
|
log.error(" Quelle fehlt: %s", src_pdf)
|
|
return
|
|
|
|
# Zielordner vorbereiten: vorhandene RST/Bilder ersetzen (aus einem Guss)
|
|
chapter_dir.mkdir(parents=True, exist_ok=True)
|
|
if img_dir.exists():
|
|
shutil.rmtree(img_dir)
|
|
# Alte .de.rst im Zielordner entfernen (Testbestand)
|
|
for old in chapter_dir.glob("*.de.rst"):
|
|
old.unlink()
|
|
|
|
# Bilder extrahieren (extract_products entfernt kleine Icons < 5KB automatisch)
|
|
img_count = ep.extract_images(src_pdf, img_dir)
|
|
dup = ep.dedup_images(img_dir)
|
|
log.info(" %d Bilder (%d Duplikate entfernt)", img_count, dup)
|
|
|
|
# Text nach RST extrahieren (positionsbasiert, Kopf-/Fusszeilen gefiltert)
|
|
blocks = ep.extract_text_to_rst(src_pdf, rst_path)
|
|
log.info(" %d Textbloecke -> %s", blocks, rst_path.name)
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# action="list": Verzeichnisliste index.de.rst
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def human_size(n: int) -> str:
|
|
if n >= 1024 * 1024:
|
|
return f"{n / (1024 * 1024):.1f} MB"
|
|
if n >= 1024:
|
|
return f"{n / 1024:.0f} KB"
|
|
return f"{n} B"
|
|
|
|
|
|
def category_from_path(rel_path: str, chapter: str) -> str:
|
|
"""Leitet eine Kategorie (z.B. Hersteller) aus dem Quellpfad ab.
|
|
|
|
Nimmt das Ordnersegment direkt unterhalb des Fortna-Top-Level bzw. ein
|
|
aussagekraeftiges Zwischensegment (Herstellername bei Lieferantendoku).
|
|
"""
|
|
parts = Path(rel_path).parts
|
|
# Lieferantendoku: Herstellername steckt meist tiefer im Pfad
|
|
# Heuristik: letztes Segment vor der Datei, das keine Sprach-/Nummernkennung ist
|
|
lang_dir = re.compile(r"^\d*_?(DE|EN|CZ)(_|$)", re.I)
|
|
skip = re.compile(r"^\d+_", )
|
|
candidates = [p for p in parts[1:-1] if not lang_dir.match(p)]
|
|
if candidates:
|
|
# bevorzugt ein Segment mit Buchstaben (Herstellername)
|
|
for c in reversed(candidates):
|
|
cleaned = skip.sub("", c)
|
|
if re.search(r"[A-Za-z]{3,}", cleaned):
|
|
return cleaned.split("-")[0].strip()
|
|
return ""
|
|
|
|
|
|
def generate_index(chapter: str, items: list[dict], source_root: Path,
|
|
chapters_dir: Path, dry_run: bool) -> None:
|
|
"""Erzeugt chapters/<kapitel>/index.de.rst mit RST-list-table."""
|
|
chapter_dir = chapters_dir / chapter
|
|
rst_path = chapter_dir / "index.de.rst"
|
|
|
|
title_map = {
|
|
"00_inhaltsverzeichnis": "Inhaltsverzeichnis / Dokumentennotizen",
|
|
"01_zertifikate/konformitaetserklaerung": "Konformitaetserklaerungen",
|
|
"01_zertifikate/konfigurationsbeschreibung": "Konfigurationsbeschreibung",
|
|
"07_ersatzteile": "Ersatzteillisten",
|
|
"08_lieferantendoku/antriebe": "Lieferantendoku - Antriebe",
|
|
"08_lieferantendoku/elektrik": "Lieferantendoku - Elektrik",
|
|
"08_lieferantendoku/pneumatik": "Lieferantendoku - Pneumatik",
|
|
"08_lieferantendoku/stahlbau": "Lieferantendoku - Stahlbau",
|
|
"08_lieferantendoku/sicherheitseinrichtungen": "Lieferantendoku - Sicherheitseinrichtungen",
|
|
"09_technische_unterlagen/layouts/mechanisch": "Layout mechanisch",
|
|
"09_technische_unterlagen/layouts/elektrisch": "Layout elektrisch",
|
|
"09_technische_unterlagen/schaltplaene": "Schaltplaene",
|
|
"09_technische_unterlagen/notstopp": "Not-Stopp",
|
|
"09_technische_unterlagen/bereichsstopp": "Bereichsstopp",
|
|
"10_anhang/pruefberichte": "Pruefberichte",
|
|
}
|
|
title = title_map.get(chapter, chapter)
|
|
|
|
log.info("LIST %-45s (%d Dateien) -> %s",
|
|
chapter, len(items), rst_path.relative_to(chapters_dir))
|
|
if dry_run:
|
|
return
|
|
|
|
chapter_dir.mkdir(parents=True, exist_ok=True)
|
|
|
|
lines: list[str] = []
|
|
lines += rst_heading(title, 1)
|
|
lines.append(".. note::")
|
|
lines.append("")
|
|
lines.append(" Automatisch generierte Verzeichnisliste aus dem Fortna-Quellmaterial.")
|
|
lines.append(" Die referenzierten Dokumente liegen im Projekt-Rohmaterial und werden")
|
|
lines.append(" hier nicht dupliziert.")
|
|
lines.append("")
|
|
lines.append(".. list-table::")
|
|
lines.append(" :header-rows: 1")
|
|
lines.append(" :widths: 34 18 12 36")
|
|
lines.append("")
|
|
lines.append(" * - Dokument")
|
|
lines.append(" - Kategorie")
|
|
lines.append(" - Groesse")
|
|
lines.append(" - Quellpfad")
|
|
for it in sorted(items, key=lambda x: x["rel_path"]):
|
|
cat = category_from_path(it["rel_path"], chapter)
|
|
lines.append(f" * - {it['filename']}")
|
|
lines.append(f" - {cat}")
|
|
lines.append(f" - {human_size(it['size_bytes'])}")
|
|
lines.append(f" - ``{it['rel_path']}``")
|
|
lines.append("")
|
|
|
|
rst_path.write_text("\n".join(lines), encoding="utf-8")
|
|
|
|
|
|
# ---------------------------------------------------------------------------
|
|
# Hauptlogik
|
|
# ---------------------------------------------------------------------------
|
|
|
|
def main() -> None:
|
|
parser = argparse.ArgumentParser(
|
|
description="Befuellt chapters/ aus dem Fortna-Inventar (Volltext + Verzeichnislisten)."
|
|
)
|
|
parser.add_argument("--inventory", default=None,
|
|
help="Pfad zum Inventar-JSON (default: results/fortna_inventory.json)")
|
|
parser.add_argument("--source-dir", default=None,
|
|
help="Fortna-Quellverzeichnis (default: aus Inventar-JSON)")
|
|
parser.add_argument("--chapters-dir", default=None,
|
|
help="Ziel chapters/-Verzeichnis (default: PROJECT/chapters)")
|
|
parser.add_argument("--lang", default="de", choices=["de", "en", "cz"],
|
|
help="Zu verarbeitende Sprache (default: de)")
|
|
parser.add_argument("--only", choices=["convert", "list"], default=None,
|
|
help="Nur eine Aktionsart ausfuehren")
|
|
grp = parser.add_mutually_exclusive_group()
|
|
grp.add_argument("--dry-run", action="store_true", default=True,
|
|
help="Nur anzeigen (Default)")
|
|
grp.add_argument("--apply", action="store_true",
|
|
help="Aenderungen tatsaechlich schreiben")
|
|
parser.add_argument("--verbose", "-v", action="store_true")
|
|
args = parser.parse_args()
|
|
|
|
logging.basicConfig(
|
|
level=logging.DEBUG if args.verbose else logging.INFO,
|
|
format="%(levelname)-7s %(message)s",
|
|
)
|
|
dry_run = not args.apply
|
|
|
|
project_root = Path(os.environ.get("PROJECT", Path(__file__).resolve().parent.parent))
|
|
inv_path = Path(args.inventory) if args.inventory else project_root / "results" / "fortna_inventory.json"
|
|
if not inv_path.exists():
|
|
log.error("Inventar nicht gefunden: %s (erst fortna_inventory.py laufen lassen)", inv_path)
|
|
sys.exit(1)
|
|
|
|
inv = load_inventory(inv_path)
|
|
source_root = Path(args.source_dir) if args.source_dir else Path(inv["source"])
|
|
chapters_dir = Path(args.chapters_dir) if args.chapters_dir else project_root / "chapters"
|
|
|
|
log.info("Quelle: %s", source_root)
|
|
log.info("Ziel: %s", chapters_dir)
|
|
log.info("Sprache: %s | Modus: %s", args.lang, "APPLY" if args.apply else "DRY-RUN")
|
|
|
|
items = [i for i in inv["items"] if i["lang"] == args.lang and i["chapter"]]
|
|
|
|
# 1. Volltext-Konvertierung
|
|
if args.only in (None, "convert"):
|
|
conv = [i for i in items if i["action"] == "convert"]
|
|
log.info("--- %d Hauptanleitungen konvertieren ---", len(conv))
|
|
for it in conv:
|
|
convert_manual(it, source_root, chapters_dir, dry_run)
|
|
|
|
# 2. Verzeichnislisten
|
|
if args.only in (None, "list"):
|
|
list_items = [i for i in items if i["action"] == "list"]
|
|
by_chapter: dict[str, list[dict]] = defaultdict(list)
|
|
for it in list_items:
|
|
by_chapter[it["chapter"]].append(it)
|
|
log.info("--- %d Verzeichnislisten erzeugen ---", len(by_chapter))
|
|
for chapter in sorted(by_chapter):
|
|
generate_index(chapter, by_chapter[chapter], source_root, chapters_dir, dry_run)
|
|
|
|
if dry_run:
|
|
log.info("DRY-RUN abgeschlossen. Mit --apply tatsaechlich schreiben.")
|
|
else:
|
|
log.info("Fertig.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|