texdocxdrafter 0.1.2__py3-none-any.whl

texdocxdrafter/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.2"

texdocxdrafter/audit.py

@@ -0,0 +1,113 @@
+"""Coverage report: every construct that was dropped, approximated or could not be resolved."""
+from __future__ import annotations
+
+from collections import Counter
+from dataclasses import dataclass, field
+from pathlib import Path
+
+# kind -> (heading, severity). Severity "info" items are expected presentation drops.
+KINDS = {
+    "raw": "Unsupported constructs kept as visible Drafter Todo text",
+    "dropped": "Presentation commands dropped",
+    "direct-format": "Direct formatting used (no matching Word style)",
+    "macro": "Macros that could not be expanded",
+    "conditional": "TeX conditionals not resolved",
+    "math": "Math kept as LaTeX text",
+    "figure": "Figures",
+    "label": "Labels and cross-references",
+    "numbering": "Numbering differences between LaTeX and Word",
+    "harvest": "Citation harvest",
+    "table": "Tables",
+    "style": "Style map",
+    "words": "Word-count check",
+    "fidelity": "Content check (tree against docx)",
+    "preflight": "Preflight",
+    "other": "Other",
+}
+
+
+@dataclass
+class Entry:
+    kind: str
+    message: str
+    loc: tuple[str, int] | None = None
+    severity: str = "warn"
+
+    def where(self) -> str:
+        return f"{self.loc[0]}:{self.loc[1]}" if self.loc else ""
+
+
+@dataclass
+class Audit:
+    entries: list[Entry] = field(default_factory=list)
+    census: Counter = field(default_factory=Counter)
+    info: dict = field(default_factory=dict)
+
+    def add(self, kind: str, message: str, loc=None, severity: str = "warn") -> None:
+        self.entries.append(Entry(kind, message, loc, severity))
+
+    def count(self, construct: str, n: int = 1) -> None:
+        self.census[construct] += n
+
+    def of(self, kind: str) -> list[Entry]:
+        return [e for e in self.entries if e.kind == kind]
+
+    def warnings(self) -> list[Entry]:
+        return [e for e in self.entries if e.severity != "info"]
+
+    def render(self, title: str, stylemap: dict | None = None, style_usage: dict | None = None) -> str:
+        lines = [f"# texdocxdrafter report: {title}", ""]
+        n_warn = len(self.warnings())
+        lines.append(f"{n_warn} items need attention; {len(self.entries) - n_warn} informational.")
+        lines.append("")
+        if self.info:
+            lines.append("## Run summary")
+            lines.append("")
+            for k, v in self.info.items():
+                lines.append(f"- {k}: {v}")
+            lines.append("")
+        if style_usage:
+            lines.append("## Style usage")
+            lines.append("")
+            lines.append("| Style | Paragraphs |")
+            lines.append("|---|---|")
+            for k, v in sorted(style_usage.items(), key=lambda kv: -kv[1]):
+                lines.append(f"| {k} | {v} |")
+            lines.append("")
+        if self.census:
+            lines.append("## Construct census")
+            lines.append("")
+            lines.append("| Construct | Count |")
+            lines.append("|---|---|")
+            for k, v in sorted(self.census.items(), key=lambda kv: (-kv[1], kv[0])):
+                lines.append(f"| {k} | {v} |")
+            lines.append("")
+        if stylemap:
+            lines.append("## Style map used")
+            lines.append("")
+            for sect in ("paragraph", "character"):
+                lines.append(f"- {sect}: " + ", ".join(f"{k}={v}" for k, v in stylemap[sect].items()))
+            lines.append("- options: " + ", ".join(f"{k}={v}" for k, v in stylemap["options"].items()))
+            lines.append("")
+        by_kind: dict[str, list[Entry]] = {}
+        for e in self.entries:
+            by_kind.setdefault(e.kind, []).append(e)
+        for kind in KINDS:
+            items = by_kind.get(kind)
+            if not items:
+                continue
+            lines.append(f"## {KINDS[kind]} ({len(items)})")
+            lines.append("")
+            if kind == "dropped":
+                grouped = Counter(e.message for e in items)
+                for msg, n in grouped.most_common():
+                    first = next(e for e in items if e.message == msg)
+                    lines.append(f"- {msg} x{n} (first at {first.where()})")
+            else:
+                for e in items:
+                    lines.append(f"- {e.where() + ': ' if e.loc else ''}{e.message}")
+            lines.append("")
+        return "\n".join(lines).rstrip() + "\n"
+
+    def write(self, path: str | Path, title: str, **kw) -> None:
+        Path(path).write_text(self.render(title, **kw), encoding="utf-8")

texdocxdrafter/auxreader.py

@@ -0,0 +1,84 @@
+r"""Stage 5b: read labels, kinds and numbers from the .aux file (including the cleveref variant)."""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+from pathlib import Path
+
+from .expand import read_group
+
+
+@dataclass
+class AuxLabel:
+    key: str
+    number: str = ""
+    page: str = ""
+    title: str = ""
+    cref_kind: str | None = None  # section table figure equation item …
+
+
+def _groups(s: str) -> list[str]:
+    out: list[str] = []
+    i = 0
+    while i < len(s):
+        if s[i] == "{":
+            inner, i = read_group(s, i)
+            out.append(inner)
+        else:
+            i += 1
+    return out
+
+
+MAX_DEPTH = 10
+
+
+def read_aux(path: Path | None, roots: list[Path] | None = None, _seen: set | None = None,
+             _depth: int = 0, issues: list[str] | None = None) -> dict[str, AuxLabel]:
+    """Labels of an .aux file and the .aux files it ``\\@input``s, which must lie under ``roots`` (if given).
+    Decoding problems are appended to ``issues`` when given."""
+    from .preflight import inside, read_source_text
+
+    labels: dict[str, AuxLabel] = {}
+    if path is None or _depth > MAX_DEPTH:
+        return labels
+    try:
+        path = Path(path).resolve(strict=True)
+    except OSError:
+        return labels
+    if not path.is_file() or (roots and not inside(path, roots)):
+        return labels
+    seen = _seen if _seen is not None else set()
+    if path in seen:
+        return labels
+    seen.add(path)
+    for line in read_source_text(path, issues if issues is not None else []).splitlines():
+        m = re.match(r"\\newlabel\{([^}]*)\}\{(.*)\}\s*$", line)
+        if m:
+            key, rest = m.group(1), m.group(2)
+            g = _groups("{" + rest + "}")
+            fields = _groups(g[0]) if g else []
+            if key.endswith("@cref"):
+                real = key[:-5]
+                lab = labels.setdefault(real, AuxLabel(real))
+                km = re.match(r"\[([^\]]*)\]\[[^\]]*\]\[[^\]]*\](.*)", fields[0] if fields else "")
+                if km:
+                    lab.cref_kind = km.group(1)
+                continue
+            lab = labels.setdefault(key, AuxLabel(key))
+            if fields:
+                lab.number = _clean(fields[0])
+            if len(fields) > 1:
+                lab.page = _clean(fields[1])
+            if len(fields) > 2:
+                lab.title = _clean(fields[2])
+            continue
+        im = re.match(r"\\@input\{([^}]*)\}", line)
+        if im:
+            sub = path.parent / im.group(1)
+            for k, v in read_aux(sub, roots, seen, _depth + 1, issues).items():
+                labels.setdefault(k, v)
+    return labels
+
+
+def _clean(s: str) -> str:
+    return re.sub(r"\\[a-zA-Z]+\s*|[{}]", "", s).strip()