pytex-preprocessor 1.0.1__tar.gz → 1.0.5__tar.gz

{pytex_preprocessor-1.0.1 → pytex_preprocessor-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytex-preprocessor
-Version: 1.0.1
+Version: 1.0.5
 Summary: Type-safe LaTeX document generation with Python
 Author-email: Frederik Beimgraben <frederik@beimgraben.net>
 License:                     GNU GENERAL PUBLIC LICENSE

{pytex_preprocessor-1.0.1 → pytex_preprocessor-1.0.5}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "pytex-preprocessor"
-version = "1.0.1"
+version = "1.0.5"
 authors = [
   { name="Frederik Beimgraben", email="frederik@beimgraben.net" },
 ]

{pytex_preprocessor-1.0.1 → pytex_preprocessor-1.0.5}/src/pytex_api/_compile.py

@@ -102,18 +102,55 @@ def _kill_group(proc: subprocess.Popen[str]) -> None:  # pragma: no cover - timi
         proc.kill()
 
 
+def _biber_env(
+    cmd: list[str], build_dir: Path, policy: TrustPolicy, console: Console
+) -> dict[str, str] | None:
+    """A child env whose PATH includes the biber matching the document's BCF.
+
+    Mirrors ``pytex_builder.tectonic.run_tectonic``: read the BCF (probing with a
+    no-op biber if it is not written yet) to pick the right biber release, then
+    ensure it (download+cache). Returns ``None`` (inherit env) for documents
+    without biblatex, or when biber can't be obtained (e.g. network disabled) —
+    tectonic then surfaces its own error rather than us masking it.
+    """
+    tex = build_dir.parent / f"{_JOB}.tex"
+    try:
+        source = tex.read_text(encoding="utf-8", errors="ignore")
+    except OSError:
+        return None
+    # No biblatex → tectonic never invokes biber; skip the extra probe pass.
+    if "biblatex" not in source:
+        return None
+    try:
+        from pytex_builder.tectonic import biber_for_build, env_with_biber, probe_bcf
+    except Exception:  # pragma: no cover - import guard
+        return None
+    job = _JOB
+    try:
+        biber = biber_for_build(build_dir, job, console)
+        if biber is None and policy.allow_network:
+            probe_bcf(cmd)
+            biber = biber_for_build(build_dir, job, console)
+    except Exception as exc:  # pragma: no cover - infra
+        console.warn(f"biber setup skipped: {exc}")
+        return None
+    return env_with_biber(biber) if biber is not None else None
+
+
 def _run_confined(
     cmd: list[str],
     cwd: Path,
     limits: BuildLimits,
     *,
     apply_rlimits: bool,
+    env: Mapping[str, str] | None = None,
 ) -> tuple[int, str]:
     """Run ``cmd`` with rlimits + a hard wall-clock kill; return (rc, output).
 
     ``apply_rlimits`` is the in-process ``setrlimit`` floor; it is switched off
     for the Podman path, where the container's cgroup flags do the capping (an
     rlimit on the ``podman`` *client* would not reach the build inside).
+    ``env`` overrides the child environment (e.g. a PATH that includes biber).
     """
     posix = os.name == "posix"
     preexec = make_rlimit_preexec(limits) if (apply_rlimits and posix) else None
@@ -126,6 +163,7 @@ def _run_confined(
             text=True,
             start_new_session=posix,
             preexec_fn=preexec,
+            env=dict(env) if env is not None else None,
         )
     except OSError as exc:
         raise CompileError(f"could not start tectonic: {exc}") from exc
@@ -256,8 +294,17 @@ def compile_to_pdf(
             )
         binary = _locate_tectonic(policy, console)
         cmd = build_tectonic_cmd(binary, tex_file, build_dir, policy)
+        # biblatex docs (report/protocol) make tectonic shell out to ``biber``;
+        # it is not bundled, so provide a version-matched one on PATH (probe the
+        # BCF, then download+cache the matching biber). Without it tectonic dies
+        # with "Running external tool biber ... No such file or directory".
+        biber_env = _biber_env(cmd, build_dir, policy, console)
         rc, out = _run_confined(
-            cmd, workdir, req.limits, apply_rlimits=policy.apply_rlimits
+            cmd,
+            workdir,
+            req.limits,
+            apply_rlimits=policy.apply_rlimits,
+            env=biber_env,
         )
 
     log = truncate_log(out, req.limits)

{pytex_preprocessor-1.0.1 → pytex_preprocessor-1.0.5}/src/pytex_api/_render.py

@@ -63,9 +63,36 @@ def _render_markdown_source(
     write_inline_fonts = getattr(document, "write_inline_fonts", None)
     if callable(write_inline_fonts):
         write_inline_fonts(str(workdir))
+    # Same for the (svg->pdf converted) logos and any inline images: the tikz
+    # title/footer overlays reference them by the relative ``logos/<file>`` path,
+    # so the files must exist next to the .tex or tectonic fails with
+    # "Unable to load picture or PDF file 'logos/...'". Best-effort: SVG logos are
+    # converted via ``inkscape``; if it is absent (e.g. a warm-up render with no
+    # converter on PATH) we log and continue rather than failing the whole render —
+    # PDF logos (the common report/protocol case) need no converter and still
+    # materialise. ``OSError`` covers a missing inkscape binary; ``CalledProcessError``
+    # a conversion error.
+    _materialise_best_effort(document, "write_inline_logos", workdir)
+    _materialise_best_effort(document, "write_inline_images", workdir)
     return document.rendered
 
 
+def _materialise_best_effort(document: object, method: str, workdir: Path) -> None:
+    """Call ``document.<method>(workdir)`` if present; swallow converter errors."""
+    import logging
+    import subprocess
+
+    fn = getattr(document, method, None)
+    if not callable(fn):
+        return
+    try:
+        fn(str(workdir))
+    except (OSError, subprocess.CalledProcessError) as exc:  # pragma: no cover - infra
+        logging.getLogger("pytex_api").warning(
+            "%s could not materialise assets (%s); continuing without them", method, exc
+        )
+
+
 def render_to_latex(req: BuildRequest, policy: TrustPolicy, workdir: Path) -> str:
     """Render the request's source to a LaTeX string under the trust policy.
 

{pytex_preprocessor-1.0.1 → pytex_preprocessor-1.0.5}/src/pytex_builder/tectonic.py

@@ -21,7 +21,15 @@ import zipfile
 from pathlib import Path
 from typing import TYPE_CHECKING
 
-__all__ = ["BuildError", "ensure_tectonic", "run_makeindex", "run_tectonic"]
+__all__ = [
+    "BuildError",
+    "biber_for_build",
+    "ensure_tectonic",
+    "env_with_biber",
+    "probe_bcf",
+    "run_makeindex",
+    "run_tectonic",
+]
 
 if TYPE_CHECKING:
     from .console import Console
@@ -373,7 +381,7 @@ def _ensure_biber(version: str, console: Console) -> Path:
     return cached
 
 
-def _biber_for_build(build_dir: Path, job: str, console: Console) -> Path | None:
+def biber_for_build(build_dir: Path, job: str, console: Console) -> Path | None:
     """Return a correctly-versioned biber if the BCF file reveals a mismatch."""
     bcf = build_dir / f"{job}.bcf"
     if not bcf.exists():
@@ -400,13 +408,13 @@ def _biber_for_build(build_dir: Path, job: str, console: Console) -> Path | None
     return _ensure_biber(biber_ver, console)
 
 
-def _env_with_biber(biber: Path) -> dict[str, str]:
+def env_with_biber(biber: Path) -> dict[str, str]:
     env = os.environ.copy()
     env["PATH"] = str(biber.parent) + os.pathsep + env.get("PATH", "")
     return env
 
 
-def _probe_bcf(cmd: list[str]) -> None:
+def probe_bcf(cmd: list[str]) -> None:
     """Run tectonic with a no-op biber so the BCF file is written to build_dir.
 
     Tectonic cleans up intermediates when biber fails, so the BCF is never
@@ -419,7 +427,7 @@ def _probe_bcf(cmd: list[str]) -> None:
         fake = tmpdir / "biber"
         fake.write_text("#!/bin/sh\nexit 0\n")
         fake.chmod(0o755)
-        subprocess.run(cmd, env=_env_with_biber(fake), capture_output=True)
+        subprocess.run(cmd, env=env_with_biber(fake), capture_output=True)
     finally:
         shutil.rmtree(tmpdir, ignore_errors=True)
 
@@ -453,12 +461,12 @@ def run_tectonic(
     # Determine the right biber from the BCF. If no BCF exists yet (first build
     # or after a clean), run a silent probe pass with a no-op biber so tectonic
     # writes the BCF to build_dir without actually needing biber installed.
-    biber = _biber_for_build(build_dir, job, console)
+    biber = biber_for_build(build_dir, job, console)
     if biber is None:
-        _probe_bcf(cmd)
-        biber = _biber_for_build(build_dir, job, console)
+        probe_bcf(cmd)
+        biber = biber_for_build(build_dir, job, console)
 
-    env = _env_with_biber(biber) if biber is not None else None
+    env = env_with_biber(biber) if biber is not None else None
     proc = subprocess.run(cmd, env=env)
     if proc.returncode != 0:
         log = build_dir / f"{tex_file.stem}.log"

{pytex_preprocessor-1.0.1 → pytex_preprocessor-1.0.5}/src/pytex_preprocessor.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytex-preprocessor
-Version: 1.0.1
+Version: 1.0.5
 Summary: Type-safe LaTeX document generation with Python
 Author-email: Frederik Beimgraben <frederik@beimgraben.net>
 License:                     GNU GENERAL PUBLIC LICENSE