pdfa-parser 0.1.0__py3-none-any.whl

pdfa_parser/__init__.py

@@ -0,0 +1,58 @@
+"""pdfa-parser – Convert PDFs to PDF/A and validate compliance.
+
+Quick-start::
+
+    from pdfa_parser import PdfParser, create_parser
+
+    # one-liner: uses default GhostScript + VeraPDF adapters
+    parser = create_parser()
+    parser.convert("input.pdf", "output.pdf")
+    result = parser.validate("output.pdf")
+    print(result.compliant)
+"""
+
+from pdfa_parser.dependencies import DependencyManager
+from pdfa_parser.implementations.ghostscript_adapter import GhostScriptAdapter
+from pdfa_parser.implementations.verapdf_adapter import VeraPDFAdapter
+from pdfa_parser.interfaces.base_adapter import IBaseAdapter
+from pdfa_parser.interfaces.binary_executer import BinaryExecuter
+from pdfa_parser.pdf_parser import PdfParser, ValidationResult
+
+
+def create_parser(
+    *,
+    pdfa_level: int = 2,
+    with_verapdf: bool = True,
+    extra_gs_args: tuple[str, ...] = (),
+) -> PdfParser:
+    """Factory that builds a :class:`PdfParser` with default adapters.
+
+    Args:
+        pdfa_level: PDF/A conformance level (1, 2 or 3).
+        with_verapdf: If ``True`` (default) attach the VeraPDF executor
+            so :meth:`PdfParser.validate` is available.
+        extra_gs_args: Extra CLI flags appended to every GhostScript call.
+
+    Returns:
+        A ready-to-use :class:`PdfParser` instance.
+    """
+    gs = BinaryExecuter(GhostScriptAdapter())
+    verapdf = BinaryExecuter(VeraPDFAdapter()) if with_verapdf else None
+    return PdfParser(
+        gs_executer=gs,
+        verapdf_executer=verapdf,
+        pdfa_level=pdfa_level,
+        extra_gs_args=extra_gs_args,
+    )
+
+
+__all__ = [
+    "DependencyManager",
+    "PdfParser",
+    "ValidationResult",
+    "GhostScriptAdapter",
+    "VeraPDFAdapter",
+    "IBaseAdapter",
+    "BinaryExecuter",
+    "create_parser",
+]

pdfa_parser/__main__.py

@@ -0,0 +1,5 @@
+"""Allow ``python -m pdfa_parser``."""
+
+from pdfa_parser.main import main
+
+main()

pdfa_parser/_bootstrap.py

@@ -0,0 +1,44 @@
+"""Bootstrap compatibility shim.
+
+This module re-exports symbols from the new :mod:`pdfa_parser.dependencies`
+package so that existing code importing from ``_bootstrap`` continues to work.
+
+.. deprecated::
+    Import from :mod:`pdfa_parser.dependencies` instead.
+"""
+
+from __future__ import annotations
+
+from pdfa_parser.dependencies import (
+    BIN_DIR,
+    GS_DIR,
+    JRE_DIR,
+    VERAPDF_DIR,
+    DependencyManager,
+)
+from pdfa_parser.dependencies._base import OS
+from pdfa_parser.dependencies._ghostscript import _gs_binary_name
+from pdfa_parser.dependencies._verapdf import _verapdf_binary_name
+
+_manager = DependencyManager()
+
+
+def ensure_binaries(*, ghostscript: bool = True, verapdf: bool = True) -> None:
+    """Legacy API.  Prefer :class:`DependencyManager`."""
+    if ghostscript:
+        _manager.ensure_ghostscript()
+    if verapdf:
+        _manager.ensure_verapdf()
+
+
+__all__ = [
+    "BIN_DIR",
+    "DependencyManager",
+    "GS_DIR",
+    "JRE_DIR",
+    "OS",
+    "VERAPDF_DIR",
+    "_gs_binary_name",
+    "_verapdf_binary_name",
+    "ensure_binaries",
+]

pdfa_parser/_test_runner.py

@@ -0,0 +1,15 @@
+"""Test runner entry-point so ``uv run test`` works.
+
+This is registered as ``test`` in ``[project.scripts]``.
+"""
+
+from __future__ import annotations
+
+import sys
+
+
+def main() -> None:
+    """Invoke pytest programmatically and exit with its return code."""
+    import pytest
+
+    sys.exit(pytest.main(["-v", "tests/"]))

pdfa_parser/data/PDFA_def.ps

@@ -0,0 +1,91 @@
+%!
+% This is a sample prefix file for creating a PDF/A document.
+% Users should modify entries marked with "Customize".
+% This assumes an ICC profile resides in the file (srgb.icc),
+% in the current directory unless the user modifies the corresponding line below.
+
+% Define entries in the document Info dictionary :
+[ /Title (Title)       % Customise
+  /DOCINFO pdfmark
+
+% Define an ICC profile :
+/ICCProfile (srgb.icc) % Customise
+def
+
+[/_objdef {icc_PDFA} /type /stream /OBJ pdfmark
+
+%% This code attempts to set the /N (number of components) key for the ICC colour space.
+%% To do this it checks the ColorConversionStrategy or the device ProcessColorModel if
+%% ColorConversionStrategy is not set.
+%% This is not 100% reliable. A better solution is for the user to edit this and replace
+%% the code between the ---8<--- lines with a simple declaration like:
+%%   /N 3
+%% where the value of N is the number of components from the profile defined in /ICCProfile above.
+%%
+[{icc_PDFA}
+<<
+%% ----------8<--------------8<-------------8<--------------8<----------
+  systemdict /ColorConversionStrategy known {
+    systemdict /ColorConversionStrategy get cvn dup /Gray eq {
+      pop /N 1 false
+    }{
+      dup /RGB eq {
+        pop /N 3 false
+      }{
+        /CMYK eq {
+          /N 4 false
+        }{
+          (\tColorConversionStrategy not a device space, falling back to ProcessColorModel, output may not be valid PDF/A.\n)=
+          true
+        } ifelse
+      } ifelse
+    } ifelse
+  } {
+    (\tColorConversionStrategy not set, falling back to ProcessColorModel, output may not be valid PDF/A.\n)=
+    true
+  } ifelse
+
+  {
+    currentpagedevice /ProcessColorModel get
+    dup /DeviceGray eq {
+      pop /N 1
+    }{
+      dup /DeviceRGB eq {
+        pop /N 3
+      }{
+        dup /DeviceCMYK eq {
+          pop /N 4
+        } {
+          (\tProcessColorModel not a device space.)=
+          /ProcessColorModel cvx /rangecheck signalerror
+        } ifelse
+      } ifelse
+    } ifelse
+  } if
+%% ----------8<--------------8<-------------8<--------------8<----------
+
+>> /PUT pdfmark
+[
+{icc_PDFA}
+{ICCProfile (r) file} stopped
+{
+  (\n\tFailed to open the supplied ICCProfile for reading. This may be due to\n) print
+  (\t  an incorrect filename or a failure to add --permit-file-read=<profile>\n) print
+  (\t  to the command line. This PostScript program needs to open the file\n) print
+  (\t  and you must explicitly grant it permission to do so.\n\n) print
+  (\tPDF/A processing aborted, output may not be a PDF/A file.\n\n) print
+  cleartomark
+}
+{
+  /PUT pdfmark
+  % Define the output intent dictionary :
+
+  [/_objdef {OutputIntent_PDFA} /type /dict /OBJ pdfmark
+  [{OutputIntent_PDFA} <<
+    /Type /OutputIntent               % Must be so (the standard requires).
+    /S /GTS_PDFA1                     % Must be so (the standard requires).
+    /DestOutputProfile {icc_PDFA}     % Must be so (see above).
+    /OutputConditionIdentifier (sRGB) % Customize
+  >> /PUT pdfmark
+  [{Catalog} <</OutputIntents [ {OutputIntent_PDFA} ]>> /PUT pdfmark
+} ifelse

pdfa_parser/dependencies/__init__.py

@@ -0,0 +1,25 @@
+"""Dependency management for external tools (GhostScript, JRE, VeraPDF).
+
+This package replaces the monolithic ``_bootstrap`` module with a structured
+OOP design built around the :class:`Dependency` / :class:`ResolutionStrategy`
+abstractions and a high-level :class:`DependencyManager` orchestrator.
+"""
+
+from pdfa_parser.dependencies._base import BIN_DIR, Dependency, ResolutionStrategy
+from pdfa_parser.dependencies._ghostscript import GS_DIR, GhostScriptDependency
+from pdfa_parser.dependencies._jre import JRE_DIR, JREDependency
+from pdfa_parser.dependencies._manager import DependencyManager
+from pdfa_parser.dependencies._verapdf import VERAPDF_DIR, VeraPDFDependency
+
+__all__ = [
+    "BIN_DIR",
+    "Dependency",
+    "DependencyManager",
+    "GhostScriptDependency",
+    "GS_DIR",
+    "JRE_DIR",
+    "JREDependency",
+    "ResolutionStrategy",
+    "VeraPDFDependency",
+    "VERAPDF_DIR",
+]

pdfa_parser/dependencies/_base.py

@@ -0,0 +1,204 @@
+"""Base abstractions and shared utilities for dependency resolution.
+
+Provides :class:`Dependency` (Template Method) and :class:`ResolutionStrategy`
+(Strategy pattern) as the two core building blocks.  Concrete dependencies
+implement ``_find_binary`` and ``_strategies``; the base class handles caching,
+logging, and the resolve-or-fail loop.
+"""
+
+from __future__ import annotations
+
+import logging
+import os
+import platform
+import shutil
+import stat
+import tarfile
+import urllib.request
+import zipfile
+from abc import ABC, abstractmethod
+from pathlib import Path
+
+log = logging.getLogger("pdfa_parser.dependencies")
+
+# ── Platform detection ───────────────────────────────────────────────
+
+OS = platform.system().lower()
+ARCH = platform.machine().lower()
+_ARCH_MAP = {"x86_64": "x64", "amd64": "x64", "aarch64": "aarch64", "arm64": "aarch64"}
+NORM_ARCH = _ARCH_MAP.get(ARCH, ARCH)
+
+# ── Layout ───────────────────────────────────────────────────────────
+
+_PKG_DIR = Path(__file__).resolve().parent.parent  # pdfa_parser/
+_SRC_DIR = _PKG_DIR.parent  # src/
+
+
+def _resolve_bin_dir() -> Path:
+    """Return the directory where downloaded binaries are stored.
+
+    * **Development / editable install** → ``<repo>/src/bin``
+      (detected by the presence of a ``pyproject.toml`` nearby).
+    * **Regular pip install** → ``~/.local/share/pdfa-parser/bin``
+      so we always have a writable location.
+    """
+    dev_bin = _SRC_DIR / "bin"
+    dev_marker = _SRC_DIR.parent / "pyproject.toml"
+    if dev_marker.is_file():
+        return dev_bin
+
+    data_home = os.environ.get("XDG_DATA_HOME", "")
+    if data_home:
+        return Path(data_home) / "pdfa-parser" / "bin"
+    if OS == "windows":
+        base = Path(os.environ.get("LOCALAPPDATA", Path.home() / "AppData" / "Local"))
+        return base / "pdfa-parser" / "bin"
+    return Path.home() / ".local" / "share" / "pdfa-parser" / "bin"
+
+
+BIN_DIR = _resolve_bin_dir()
+
+# ── Shared utilities ─────────────────────────────────────────────────
+
+
+def init_logging() -> None:
+    """Ensure the dependency logger has at least one handler."""
+    if not log.handlers:
+        h = logging.StreamHandler()
+        h.setFormatter(logging.Formatter("[pdfa-parser] %(message)s"))
+        log.addHandler(h)
+        log.setLevel(logging.INFO)
+
+
+def download(url: str, dest: Path) -> None:
+    """Download *url* to *dest*."""
+    log.info("Downloading %s ...", url)
+    req = urllib.request.Request(url, headers={"User-Agent": "pdfa-parser/1"})
+    with urllib.request.urlopen(req) as resp, open(dest, "wb") as f:
+        shutil.copyfileobj(resp, f)
+    log.info("Saved %s (%.1f MB)", dest.name, dest.stat().st_size / 1_048_576)
+
+
+def ensure_dir(d: Path) -> None:
+    """Create *d* and all parents if they don't exist."""
+    d.mkdir(parents=True, exist_ok=True)
+
+
+def chmod_executable(p: Path) -> None:
+    """Add the executable bit on Unix systems."""
+    if OS != "windows":
+        p.chmod(p.stat().st_mode | stat.S_IEXEC | stat.S_IXGRP | stat.S_IXOTH)
+
+
+def extract_archive(archive: Path, dest: Path) -> None:
+    """Extract a ``.zip`` or ``.tar.gz`` archive into *dest*."""
+    if archive.suffix == ".zip":
+        with zipfile.ZipFile(archive) as zf:
+            zf.extractall(dest)
+    elif archive.name.endswith(".tar.gz"):
+        with tarfile.open(archive, "r:gz") as tar:
+            tar.extractall(dest, filter="data")
+    else:
+        raise ValueError(f"Unsupported archive format: {archive.name}")
+
+
+# ── Abstract classes ─────────────────────────────────────────────────
+
+
+class ResolutionStrategy(ABC):
+    """A single way to obtain a dependency binary.
+
+    Each strategy either succeeds (returns the binary :class:`Path`) or
+    indicates failure (returns ``None``) so the caller can fall through
+    to the next strategy.
+    """
+
+    @abstractmethod
+    def try_resolve(self) -> Path | None:
+        """Attempt to resolve the dependency.
+
+        Returns:
+            The path to the usable binary, or ``None`` when this strategy
+            cannot provide it.
+        """
+
+
+class Dependency(ABC):
+    """An external tool required by the library at runtime.
+
+    Uses the **Template Method** pattern: :meth:`ensure` drives the
+    resolution loop while subclasses supply :meth:`_find_binary` (check
+    for an already-installed binary) and :meth:`_strategies` (ordered
+    list of :class:`ResolutionStrategy` instances to try).
+
+    The resolved path is cached so repeated :meth:`ensure` calls are
+    essentially free.
+    """
+
+    def __init__(self) -> None:
+        self._resolved_path: Path | None = None
+
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Human-readable dependency name (e.g. ``'GhostScript'``)."""
+
+    @abstractmethod
+    def _find_binary(self) -> Path | None:
+        """Look for an already-installed binary.
+
+        Return its path, or ``None`` if not found.  This should check
+        only the **local** install directory — system-wide lookups belong
+        in a :class:`ResolutionStrategy`.
+        """
+
+    @abstractmethod
+    def _strategies(self) -> list[ResolutionStrategy]:
+        """Return an ordered list of resolution strategies to try."""
+
+    # ── public API ───────────────────────────────────────────────────
+
+    def is_available(self) -> bool:
+        """``True`` if the binary is already installed locally."""
+        return self._find_binary() is not None
+
+    @property
+    def path(self) -> Path:
+        """Resolved binary path.  Valid only after :meth:`ensure`."""
+        if self._resolved_path is None:
+            raise RuntimeError(
+                f"{self.name} has not been resolved yet. Call ensure() first."
+            )
+        return self._resolved_path
+
+    def ensure(self) -> Path:
+        """Ensure the dependency is available.  Idempotent.
+
+        Returns:
+            Absolute path to the binary.
+
+        Raises:
+            RuntimeError: If no strategy can provide the binary.
+        """
+        if self._resolved_path is not None:
+            return self._resolved_path
+
+        existing = self._find_binary()
+        if existing is not None:
+            self._resolved_path = existing
+            return existing
+
+        init_logging()
+        log.info("=== Setting up %s ===", self.name)
+
+        for strategy in self._strategies():
+            result = strategy.try_resolve()
+            if result is not None:
+                self._resolved_path = result
+                log.info("%s ready: %s", self.name, result)
+                return result
+
+        raise RuntimeError(
+            f"Could not resolve '{self.name}': no resolution strategy succeeded. "
+            f"Install it manually or check your internet connection."
+        )

pdfa_parser/dependencies/_ghostscript.py

@@ -0,0 +1,142 @@
+"""GhostScript dependency resolution."""
+
+from __future__ import annotations
+
+import shutil
+import subprocess
+from pathlib import Path
+
+from pdfa_parser.dependencies._base import (
+    BIN_DIR,
+    OS,
+    Dependency,
+    ResolutionStrategy,
+    chmod_executable,
+    download,
+    ensure_dir,
+    extract_archive,
+    log,
+)
+
+GS_DIR = BIN_DIR / "ghostscript"
+
+GITHUB_RAW = "https://raw.githubusercontent.com/Ilusinusmate/pdfa-parser/main"
+
+GS_ARCHIVES: dict[str, str] = {
+    "windows": "gs_win64.zip",
+    "linux": "gs_linux_x64.tar.gz",
+}
+
+
+def _gs_binary_name() -> str:
+    return "gswin64c.exe" if OS == "windows" else "gs"
+
+
+# ── Strategies ───────────────────────────────────────────────────────
+
+
+class SystemGhostScriptStrategy(ResolutionStrategy):
+    """Use a system-installed ``gs`` directly from PATH."""
+
+    def try_resolve(self) -> Path | None:
+        system_gs = shutil.which("gs") if OS != "windows" else shutil.which("gswin64c")
+        if system_gs is None:
+            return None
+        log.info("Using system GhostScript: %s", system_gs)
+        return Path(system_gs)
+
+
+class PackageManagerStrategy(ResolutionStrategy):
+    """Install GhostScript via the system package manager (apt-get).
+
+    Only works on Debian / Ubuntu-based systems (common in Docker images).
+    Requires root or sudo access.
+    """
+
+    def try_resolve(self) -> Path | None:
+        if OS != "linux":
+            return None
+        if shutil.which("apt-get") is None:
+            return None
+
+        log.info("Installing GhostScript via apt-get ...")
+        try:
+            subprocess.run(
+                ["apt-get", "update", "-qq"],
+                check=True,
+                capture_output=True,
+                timeout=120,
+            )
+            subprocess.run(
+                ["apt-get", "install", "-y", "-qq", "ghostscript"],
+                check=True,
+                capture_output=True,
+                timeout=120,
+            )
+        except (
+            subprocess.CalledProcessError,
+            FileNotFoundError,
+            PermissionError,
+        ) as exc:
+            log.warning("apt-get install ghostscript failed: %s", exc)
+            return None
+
+        gs = shutil.which("gs")
+        if gs is None:
+            return None
+        log.info("Installed GhostScript via apt-get: %s", gs)
+        return Path(gs)
+
+
+class GitHubArchiveStrategy(ResolutionStrategy):
+    """Download the compressed GhostScript archive from the GitHub repo."""
+
+    def try_resolve(self) -> Path | None:
+        archive_name = GS_ARCHIVES.get(OS)
+        if archive_name is None:
+            return None
+
+        local_archive = BIN_DIR / archive_name
+        if not local_archive.is_file():
+            ensure_dir(BIN_DIR)
+            try:
+                download(f"{GITHUB_RAW}/src/bin/{archive_name}", local_archive)
+            except Exception as exc:  # noqa: BLE001
+                log.warning("GitHub archive download failed: %s", exc)
+                return None
+
+        ensure_dir(GS_DIR)
+        extract_archive(local_archive, GS_DIR)
+
+        binary = GS_DIR / _gs_binary_name()
+        if not binary.is_file():
+            return None
+        chmod_executable(binary)
+        return binary
+
+
+# ── Dependency ───────────────────────────────────────────────────────
+
+
+class GhostScriptDependency(Dependency):
+    """Resolves GhostScript: system PATH → apt-get → GitHub archive."""
+
+    @property
+    def name(self) -> str:
+        return "GhostScript"
+
+    def _find_binary(self) -> Path | None:
+        # Check local bin dir first
+        binary = GS_DIR / _gs_binary_name()
+        if binary.is_file():
+            return binary
+        # Then check system PATH
+        system_gs = shutil.which(_gs_binary_name())
+        return Path(system_gs) if system_gs else None
+
+    def _strategies(self) -> list[ResolutionStrategy]:
+        return [
+            SystemGhostScriptStrategy(),
+            PackageManagerStrategy(),
+            GitHubArchiveStrategy(),
+        ]

pdfa_parser/dependencies/_jre.py

@@ -0,0 +1,105 @@
+"""JRE (Adoptium Temurin) dependency resolution."""
+
+from __future__ import annotations
+
+import shutil
+import tarfile
+import tempfile
+import zipfile
+from pathlib import Path
+
+from pdfa_parser.dependencies._base import (
+    BIN_DIR,
+    NORM_ARCH,
+    OS,
+    Dependency,
+    ResolutionStrategy,
+    chmod_executable,
+    download,
+    ensure_dir,
+    log,
+)
+
+JRE_DIR = BIN_DIR / "jre"
+
+ADOPTIUM_JRE_VERSION = "21"
+
+
+def _java_binary_name() -> str:
+    return "java.exe" if OS == "windows" else "java"
+
+
+def _find_java_in(root: Path) -> Path | None:
+    """Recursively search *root* for the ``java`` binary."""
+    name = _java_binary_name()
+    for candidate in root.rglob(name):
+        if candidate.is_file():
+            return candidate
+    return None
+
+
+def _adoptium_url() -> str:
+    os_name = "mac" if OS == "darwin" else OS
+    return (
+        f"https://api.adoptium.net/v3/binary/latest/"
+        f"{ADOPTIUM_JRE_VERSION}/ga/{os_name}/{NORM_ARCH}"
+        f"/jre/hotspot/normal/eclipse"
+    )
+
+
+# ── Strategies ───────────────────────────────────────────────────────
+
+
+class SystemJavaStrategy(ResolutionStrategy):
+    """Use the system-installed ``java`` from PATH."""
+
+    def try_resolve(self) -> Path | None:
+        java = shutil.which("java")
+        if java is None:
+            return None
+        log.info("Using system Java: %s", java)
+        return Path(java)
+
+
+class AdoptiumDownloadStrategy(ResolutionStrategy):
+    """Download the Adoptium Temurin JRE."""
+
+    def try_resolve(self) -> Path | None:
+        ensure_dir(JRE_DIR)
+        url = _adoptium_url()
+
+        with tempfile.TemporaryDirectory() as tmp:
+            tmp_path = Path(tmp)
+            if OS == "windows":
+                archive = tmp_path / "jre.zip"
+                download(url, archive)
+                with zipfile.ZipFile(archive) as zf:
+                    zf.extractall(JRE_DIR)
+            else:
+                archive = tmp_path / "jre.tar.gz"
+                download(url, archive)
+                with tarfile.open(archive, "r:gz") as tar:
+                    tar.extractall(JRE_DIR, filter="data")
+
+        java = _find_java_in(JRE_DIR)
+        if java is None:
+            raise RuntimeError("java not found after JRE extraction")
+        chmod_executable(java)
+        return java
+
+
+# ── Dependency ───────────────────────────────────────────────────────
+
+
+class JREDependency(Dependency):
+    """Resolves Java: system PATH → Adoptium download."""
+
+    @property
+    def name(self) -> str:
+        return "JRE"
+
+    def _find_binary(self) -> Path | None:
+        return _find_java_in(JRE_DIR)
+
+    def _strategies(self) -> list[ResolutionStrategy]:
+        return [SystemJavaStrategy(), AdoptiumDownloadStrategy()]