pytex-preprocessor 1.0.3__tar.gz → 1.0.6__tar.gz

{pytex_preprocessor-1.0.3 → pytex_preprocessor-1.0.6}/PKG-INFO

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

{pytex_preprocessor-1.0.3 → pytex_preprocessor-1.0.6}/pyproject.toml

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

{pytex_preprocessor-1.0.3 → pytex_preprocessor-1.0.6}/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.3 → pytex_preprocessor-1.0.6}/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
@@ -254,26 +262,6 @@ def _biber_cached(version: str) -> Path:
     return CACHE_DIR / "biber" / version / name
 
 
-def _biber_sources(version: str) -> list[tuple[str, str | None]]:
-    """``(url, expected_sha256 or None)`` to try in order.
-
-    For each platform candidate the mirror is tried first, then SourceForge.
-    """
-    sources: list[tuple[str, str | None]] = []
-    for sf_dir, filename, asset in _biber_candidates(version):
-        sha = BIBER_SHA256.get(asset)
-        sources.append((BIBER_MIRROR_URL.format(asset=asset), sha))
-        sources.append(
-            (
-                BIBER_RELEASE_URL.format(
-                    version=version, sf_dir=sf_dir, filename=filename
-                ),
-                sha,
-            )
-        )
-    return sources
-
-
 def _is_biber_member(name: str) -> bool:
     """Whether an archive member is the biber executable.
 
@@ -335,11 +323,36 @@ def _download_to(url: str, dest: Path, sha: str | None, console: Console) -> boo
     return True
 
 
+def _biber_runs(binary: Path) -> bool:
+    """``True`` if ``binary`` actually executes here (``biber --version`` exits 0).
+
+    The musl build is offered first (no glibc shared-lib deps) but is *dynamically*
+    linked against the musl loader; on a glibc-only host (e.g. Debian-slim) it
+    cannot exec at all ("No such file or directory"). Running it is the only
+    reliable cross-check, so we verify and fall back to the glibc build."""
+    try:
+        proc = subprocess.run(
+            [str(binary), "--version"], capture_output=True, timeout=30
+        )
+    except OSError:
+        return False
+    return proc.returncode == 0
+
+
 def _ensure_biber(version: str, console: Console) -> Path:
-    """Return a path to biber *version*, downloading from the mirror or SourceForge."""
+    """Return a path to biber *version*, downloading from the mirror or SourceForge.
+
+    Each platform candidate (musl first, then glibc) is downloaded, extracted and
+    **test-run**; the first one that actually executes here is cached. This makes
+    the choice robust on hosts that lack the musl loader or a glibc dependency."""
     cached = _biber_cached(version)
     if cached.exists():
-        return cached
+        # Re-validate: a cache poisoned by an earlier release (e.g. a musl binary
+        # that cannot exec here) must be replaced, not blindly reused.
+        if _biber_runs(cached):
+            return cached
+        console.detail("cached biber does not execute here; re-downloading")
+        cached.unlink(missing_ok=True)
 
     if not shutil.which("curl"):
         raise BuildError(
@@ -349,31 +362,49 @@ def _ensure_biber(version: str, console: Console) -> Path:
     console.step(f"Downloading biber {version}")
     cached.parent.mkdir(parents=True, exist_ok=True)
     tmp = cached.parent / "biber.download"
+    cand = cached.parent / "biber.candidate"
+    last: str | None = None
     try:
-        downloaded = False
-        for url, sha in _biber_sources(version):
-            console.detail(f"source: {url}")
-            if _download_to(url, tmp, sha, console):
-                downloaded = True
-                break
-        if not downloaded:
-            raise BuildError(
-                f"failed to download biber {version} from the mirror or SourceForge"
-            )
-        cached.write_bytes(_extract_biber_binary(tmp, version))
+        for sf_dir, filename, asset in _biber_candidates(version):
+            sha = BIBER_SHA256.get(asset)
+            urls = [
+                BIBER_MIRROR_URL.format(asset=asset),
+                BIBER_RELEASE_URL.format(
+                    version=version, sf_dir=sf_dir, filename=filename
+                ),
+            ]
+            downloaded = False
+            for url in urls:
+                console.detail(f"source: {url}")
+                if _download_to(url, tmp, sha, console):
+                    downloaded = True
+                    break
+            if not downloaded:
+                last = f"{asset}: download failed"
+                continue
+            try:
+                cand.write_bytes(_extract_biber_binary(tmp, version))
+                cand.chmod(0o755)
+            except Exception as exc:
+                last = f"{asset}: extract failed ({exc})"
+                continue
+            if _biber_runs(cand):
+                cand.replace(cached)
+                cached.chmod(0o755)
+                return cached
+            last = f"{asset}: does not execute on this platform"
+            cand.unlink(missing_ok=True)
+        raise BuildError(f"failed to obtain a working biber {version} ({last})")
     except Exception:
         if cached.exists():
             cached.unlink()
         raise
     finally:
-        if tmp.exists():
-            tmp.unlink()
-
-    cached.chmod(0o755)
-    return cached
+        tmp.unlink(missing_ok=True)
+        cand.unlink(missing_ok=True)
 
 
-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 +431,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 +450,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 +484,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.3 → pytex_preprocessor-1.0.6}/src/pytex_preprocessor.egg-info/PKG-INFO

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