texmodel 0.2.0__py3-none-any.whl

texmodel_build/_internal/env.py

@@ -0,0 +1,42 @@
+"""The hermetic environment a compile runs in (C3): only what TeX needs, nothing inherited by accident."""
+
+import os
+from collections.abc import Sequence
+
+
+def build_env(
+    *,
+    roots: Sequence[str],
+    fonts: Sequence[str] = (),
+    epoch: int | None = None,
+    cache: str | None = None,
+    inherit: Sequence[str] = (),
+) -> dict[str, str]:
+    """`roots` are paths as the compiler sees them (container paths in a container).
+
+    A trailing separator in the search variables keeps the default search path after the roots.
+    """
+    search = os.pathsep.join([".", *roots]) + os.pathsep
+    rooted = os.pathsep.join(roots) + os.pathsep if roots else ""
+    env = {
+        "TEXINPUTS": search,
+        "OPENTYPEFONTS": rooted,
+        "TTFONTS": rooted,
+        # Logs are parsed, so never hard-wrapped.
+        "max_print_line": "10000",
+        "error_line": "254",
+        "half_error_line": "238",
+    }
+    if rooted == "":
+        del env["OPENTYPEFONTS"], env["TTFONTS"]
+    if fonts:
+        env["OSFONTDIR"] = os.pathsep.join(fonts)  # families a document names but never paths
+    if cache:
+        env["TEXMFVAR"] = env["TEXMFCACHE"] = cache
+    if epoch is not None:
+        env["SOURCE_DATE_EPOCH"] = str(epoch)
+        env["FORCE_SOURCE_DATE"] = "1"
+    for name in inherit:
+        if name in os.environ:
+            env[name] = os.environ[name]
+    return env

texmodel_build/_internal/logparse.py

@@ -0,0 +1,170 @@
+"""Parse a LuaTeX/LaTeX log into typed diagnostics (C2).
+
+The compile driver runs with `max_print_line` raised, so log lines are never hard-wrapped, and with
+`-file-line-error`, so most errors read `file:line: message`; a few (a missing file) still read `! message`.
+"""
+
+import dataclasses
+import re
+from collections.abc import Callable, Sequence
+
+from ..diagnostics import (
+    Diagnostic,
+    DocumentRefusal,
+    Measure,
+    Measurement,
+    MissingCharacter,
+    MissingFile,
+    OverfullBox,
+    PackageError,
+    PackageWarning,
+    RerunNeeded,
+    TexError,
+    UndefinedControlSequence,
+    UndefinedReference,
+    overset,
+)
+
+_LOC = re.compile(r"^(?P<file>[^\s:][^:]*):(?P<line>\d+): (?P<msg>.*)$")
+_BANG = re.compile(r"^! (?P<msg>.*)$")
+_CONTEXT = re.compile(r"^l\.(?P<line>\d+) (?P<text>.*)$")
+_CS = re.compile(r"(\\[A-Za-z@]+|\\.)\s*$")
+_MISSING_CHAR = re.compile(r"^Missing character: There is no .+ \(U\+(?P<cp>[0-9A-Fa-f]+)\) in font (?P<font>.+)!$")
+_OVERFULL = re.compile(r"^Overfull \\(?P<dir>[hv])box \((?P<amount>[\d.]+)pt too (?:wide|high)\)(?P<rest>.*)$")
+_FIRST_LINE = re.compile(r"lines? (\d+)")
+_RERUN = re.compile(r"Rerun to get|Rerun LaTeX|Please \(re\)run|rerunfilecheck Warning: File .* has changed")
+_UNDEFINED_REF = re.compile(
+    r"LaTeX Warning: (?P<kind>Reference|Citation) `(?P<name>.+?)' on page \d+ undefined on input line (?P<line>\d+)"
+)
+_MISSING_FILE = re.compile(r"File `(?P<name>.+?)' not found")
+_PACKAGE_ERROR = re.compile(r"Package (?P<package>\S+) Error:\s*(?P<rest>.*)$")
+_PACKAGE_WARNING = re.compile(r"^Package (?P<package>\S+) Warning:\s*(?P<rest>.*)$")
+_ON_LINE = re.compile(r"\s*on input line (?P<line>\d+)\.?$")
+_PROBE = re.compile(r"^texmodel:probe:(?P<name>[^=\s]+)=(?P<value>.*)$")
+_FIT_PROBE = re.compile(r"^fit\.(?P<item>.+)$")
+_NEEDS_HAS = re.compile(r"^(?P<needs>[^/]+)/(?P<has>[^/]+)$")
+_REFUSE = re.compile(r"^texmodel:refuse:(?P<reason>.*)$")
+_PAGES = re.compile(r"Output written on .* \((?P<n>\d+) pages?, \d+ bytes\)")
+# Consequences of an error already reported, not errors of their own.
+_CONSEQUENCE = ("Emergency stop.", "==> Fatal error occurred")
+_LOOKAHEAD = 15
+
+
+def parse_log(text: str, measures: Sequence[Measure] = ()) -> tuple[Diagnostic, ...]:
+    """Typed diagnostics; `measures` read a package's warnings as `Overset` (B2) besides the warning itself."""
+    lines = text.splitlines()
+    found: dict[tuple[object, ...], Diagnostic] = {}
+
+    def add(diagnostic: Diagnostic) -> None:
+        # The same finding repeats per pass and per occurrence; keep one with a count.
+        key = tuple(v for k, v in sorted(dataclasses.asdict(diagnostic).items()) if k != "count") + (type(diagnostic),)
+        seen = found.get(key)
+        found[key] = dataclasses.replace(seen, count=seen.count + 1) if seen else diagnostic
+
+    for i, line in enumerate(lines):
+        if m := _LOC.match(line):
+            _error(lines, i, m["msg"], m["file"], int(m["line"]), add)
+        elif m := _BANG.match(line):
+            _error(lines, i, m["msg"], None, _context(lines, i)[0], add)
+        else:
+            _note(lines, i, add)
+    for found_one in list(found.values()):
+        if isinstance(found_one, PackageWarning):
+            for rule in measures:
+                if rule.package == found_one.package and (m := rule.pattern.search(found_one.message)):
+                    if over := overset(m["item"], m["needs"], m["has"], line=found_one.line):
+                        add(over)
+    return tuple(found.values())
+
+
+def _note(lines: list[str], i: int, add: Callable[[Diagnostic], None]) -> None:
+    """Lines that carry a finding without being an error message: missing glyphs, boxes, references, probes."""
+    line = lines[i]
+    if m := _MISSING_CHAR.match(line):
+        font = m["font"].strip('"')
+        cp = m["cp"].upper()
+        add(MissingCharacter(message=f"no glyph for U+{cp} in {font}", font=font, codepoint=int(cp, 16)))
+    elif m := _OVERFULL.match(line):
+        first = _FIRST_LINE.search(m["rest"])
+        add(
+            OverfullBox(
+                message=line, amount_pt=float(m["amount"]), direction=m["dir"], line=int(first[1]) if first else None
+            )
+        )
+    elif m := _UNDEFINED_REF.search(line):
+        message = f"{m['kind']} `{m['name']}' undefined"
+        add(UndefinedReference(message=message, kind=m["kind"], name=m["name"], line=int(m["line"])))
+    elif _RERUN.search(line):
+        add(RerunNeeded(message="rerun needed"))
+    elif m := _PROBE.match(line):
+        _probe(m, add)
+    elif m := _REFUSE.match(line):
+        add(DocumentRefusal(message=m["reason"]))
+    elif m := _PACKAGE_WARNING.match(line):
+        package = m["package"]
+        detail = [m["rest"].strip()]
+        for following in lines[i + 1 : i + 1 + _LOOKAHEAD]:
+            if not following.startswith(f"({package})"):
+                break
+            detail.append(following[len(package) + 2 :].strip())
+        message = " ".join(d for d in detail if d)
+        where = _ON_LINE.search(message)
+        add(
+            PackageWarning(
+                message=_ON_LINE.sub("", message), package=package, line=int(where["line"]) if where else None
+            )
+        )
+
+
+def _probe(m: re.Match[str], add: Callable[[Diagnostic], None]) -> None:
+    """A probe is a `Measurement`; `fit.<item>=<needs>/<has>` that does not fit is also an `Overset` (B2)."""
+    add(Measurement(message=m[0], name=m["name"], value=m["value"]))
+    if (item := _FIT_PROBE.match(m["name"])) and (fit := _NEEDS_HAS.match(m["value"])):
+        if over := overset(item["item"], fit["needs"], fit["has"]):
+            add(over)
+
+
+def page_count(text: str) -> int | None:
+    m = _PAGES.search(text)
+    return int(m["n"]) if m else None
+
+
+def _context(lines: list[str], i: int) -> tuple[int | None, str]:
+    """The `l.N <text>` line TeX prints after an error: the line number and the text up to the break."""
+    for line in lines[i + 1 : i + 1 + _LOOKAHEAD]:
+        if m := _CONTEXT.match(line):
+            return int(m["line"]), m["text"]
+    return None, ""
+
+
+def _error(
+    lines: list[str], i: int, msg: str, file: str | None, line: int | None, add: Callable[[Diagnostic], None]
+) -> None:
+    msg = msg.strip()
+    if msg.startswith(_CONSEQUENCE):
+        return
+    if msg.startswith("Undefined control sequence"):
+        top = lines[i + 1] if i + 1 < len(lines) else ""
+        cs = _CS.search(
+            top if top and not _CONTEXT.match(top) else _context(lines, i)[1]
+        )  # `<argument> \name`, else `l.N`
+        add(
+            UndefinedControlSequence(
+                message=f"undefined control sequence {cs[1] if cs else '?'}",
+                name=cs[1] if cs else "",
+                file=file,
+                line=line,
+            )
+        )
+    elif m := _MISSING_FILE.search(msg):
+        add(MissingFile(message=f"file `{m['name']}' not found", name=m["name"], file=file, line=line))
+    elif m := _PACKAGE_ERROR.search(msg):
+        package = m["package"]
+        detail = [m["rest"].strip()]
+        for following in lines[i + 1 : i + 1 + _LOOKAHEAD]:
+            if not following.startswith(f"({package})"):
+                break
+            detail.append(following[len(package) + 2 :].strip())
+        add(PackageError(message=" ".join(d for d in detail if d), package=package, file=file, line=line))
+    else:
+        add(TexError(message=msg, file=file, line=line))

texmodel_build/_internal/proofpdf.py

@@ -0,0 +1,52 @@
+"""The built-in verifier over proof-pdf (the `proof-pdf` extra): PDF/A, PDF/X-4, geometry, colour, proofing."""
+
+import asyncio
+import pathlib
+from collections.abc import Mapping, Sequence
+from typing import Any
+
+from ..diagnostics import Severity
+from ..verify import Finding
+
+
+def _profile(options: Mapping[str, Any]) -> Any:
+    from proof_pdf.models import PageGeometry, Profile
+
+    opts = dict(options)
+    if "geometry" in opts:
+        opts["geometry"] = PageGeometry(**opts["geometry"])
+    if "proof_profile" in opts:
+        opts["proof_profile"] = pathlib.Path(opts["proof_profile"])
+    if "allow_spots" in opts:
+        opts["allow_spots"] = tuple(opts["allow_spots"])
+    return Profile(**opts)
+
+
+class ProofPdf:
+    """Options are proof_pdf.models.Profile's fields (`geometry` as a table); a file is held to exactly that profile."""
+
+    name = "proof-pdf"
+
+    def unavailable(self, options: Mapping[str, Any]) -> str | None:
+        try:
+            from proof_pdf import core
+        except ImportError:
+            return "proof-pdf is not installed (pip install 'texmodel[proof-pdf]')"
+        try:
+            profile = _profile(options)
+        except (TypeError, ValueError) as exc:
+            return f"bad proof-pdf options: {exc}"
+        missing = core.missing_tools(profile)
+        return f"missing tools: {', '.join(missing)}" if missing else None
+
+    def verify(self, path: pathlib.Path, options: Mapping[str, Any]) -> Sequence[Finding]:
+        from proof_pdf import core, models
+
+        # ponytail: asyncio.run per file, so not callable inside a running loop; fine for the CLI and threads.
+        report = asyncio.run(core.verify_file(path, _profile(options)))
+        return [
+            Finding(
+                f.check, Severity.ERROR if f.severity is models.Severity.ERROR else Severity.WARNING, f.message, f.page
+            )
+            for f in report.findings
+        ]

texmodel_build/_internal/spawn.py

@@ -0,0 +1,36 @@
+"""The one place a process starts (C3): argv lists only, never a shell string.
+
+import-linter forbids importing `subprocess` anywhere else.
+"""
+
+import dataclasses
+import pathlib
+import subprocess
+from collections.abc import Sequence
+
+from ..errors import ToolchainError
+
+
+@dataclasses.dataclass(frozen=True)
+class Proc:
+    returncode: int
+    stdout: str
+    stderr: str
+    timed_out: bool = False
+
+
+def text(data: str | bytes | None) -> str:
+    return data.decode(errors="replace") if isinstance(data, bytes) else (data or "")
+
+
+def spawn(argv: Sequence[str], *, cwd: pathlib.Path | None, env: dict[str, str], timeout: float | None) -> Proc:
+    """The one place a process starts."""
+    try:
+        done = subprocess.run(  # noqa: S603
+            list(argv), cwd=cwd, env=env, capture_output=True, text=True, errors="replace", timeout=timeout, check=False
+        )
+    except subprocess.TimeoutExpired as exc:
+        return Proc(-1, text(exc.stdout), text(exc.stderr), timed_out=True)
+    except FileNotFoundError as exc:
+        raise ToolchainError(f"{argv[0]}: not found", code="TM-T001", hint="run `texmodel-build doctor`") from exc
+    return Proc(done.returncode, done.stdout, done.stderr)

texmodel_build/_internal/styscan.py

@@ -0,0 +1,37 @@
+"""What a `.sty` or `.cls` file asks TeX to load (D2): the files `\\RequirePackage` and its kin name.
+
+A scan, not an expansion: a name built from a macro (`\\RequirePackage{\\pkg}`) cannot be known and is reported as
+unchecked, never guessed.
+"""
+
+import re
+from collections.abc import Iterable
+
+_COMMENT = re.compile(r"(?<!\\)%.*")
+_LOAD = re.compile(
+    r"\\(?P<cmd>RequirePackage(?:WithOptions)?|usepackage|LoadClass(?:WithOptions)?|tcbuselibrary)"
+    r"\s*(?:\[[^\]]*\])?\s*\{(?P<names>[^}]*)\}"
+)
+SAFE_NAME = re.compile(r"[A-Za-z0-9._-]+")  # also the only names the toolchain probe will take on a shell line
+
+
+def _file(cmd: str, name: str) -> str:
+    if cmd == "tcbuselibrary":
+        return f"tcb{name}.code.tex"
+    return f"{name}.cls" if cmd.startswith("LoadClass") else f"{name}.sty"
+
+
+def needed(texts: Iterable[str]) -> tuple[list[str], list[str]]:
+    """The files named in `texts`, in order and once, and the names that are not plain file names (unchecked)."""
+    files: dict[str, None] = {}
+    unchecked: dict[str, None] = {}
+    for text in texts:
+        for m in _LOAD.finditer(_COMMENT.sub("", text)):
+            for name in (n.strip() for n in m["names"].split(",")):
+                if not name:
+                    continue
+                if SAFE_NAME.fullmatch(name):
+                    files[_file(m["cmd"], name)] = None
+                else:
+                    unchecked[name] = None
+    return list(files), list(unchecked)