apdf 1.0__tar.gz

apdf-1.0/.gitignore

@@ -0,0 +1,12 @@
+# Python-generated files
+__pycache__/
+*.py[oc]
+build/
+dist/
+wheels/
+*.egg-info
+
+# Virtual environments
+.venv
+.python-version
+ob.py

apdf-1.0/PKG-INFO

@@ -0,0 +1,86 @@
+Metadata-Version: 2.5
+Name: apdf
+Version: 1.0
+Summary: Meet another powerful PDF editing tool, designed to modify raw PDF data in hexadecimal format as well as Unicode text.
+Author: Abodx9
+License-Expression: MIT
+Keywords: Hex,PDFs,Raw,Text,Tools
+Classifier: Development Status :: 3 - Alpha
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.11
+Requires-Dist: fonttools==4.63.0
+Requires-Dist: pypdf==6.16.1
+Description-Content-Type: text/markdown
+
+# Another PDF editor
+
+**A-PDF** is a fast, command-line tool designed to replace Unicode and Hex text directly within PDF content streams. 
+
+## Features
+- **Direct Stream Replacement**: Modifies the underlying PDF streams directly for fast and precise text replacement.
+- **Unicode & Hex Support**: Replace text using standard string replacements that are automatically encoded to the document's fonts.
+- **Spacing Compensation**: Automatically compensates for `TJ` (Text Justification) width adjustments after text replacements to preserve document layout (can be disabled).
+- **Strict Mode**: Optionally fail replacements if text is missing or the font cannot encode the requested characters.
+- **Fallback Font Support**: Embed a custom TrueType font when the PDF's subset font lacks a glyph, or disable fallback entirely.
+
+## Installation
+
+You can run the tool directly using [uv](https://github.com/astral-sh/uv), which will automatically handle dependencies:
+```bash
+uv add apdf # or As a tool: uv tool install apdf
+# then Run it
+uv run apdf --help
+```
+Or simply use it in your standard Python environment.
+```bash
+pip install apdf
+
+# Run 
+apdf --help
+```
+
+## Usage
+
+```bash
+apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] input [output]
+```
+
+### Examples
+
+**Basic replacement:**
+```bash
+apdf input.pdf output.pdf -r "OldText=NewText"
+```
+
+**Multiple replacements:**
+```bash
+apdf document.pdf updated_document.pdf \
+    -r "Draft=Final" \
+    -r "2023=2024"
+```
+
+**Disable width compensation** (if characters are bunching up or spacing is incorrect):
+```bash
+apdf input.pdf output.pdf -r "foo=bar" -nopa
+```
+
+**Strict mode** (fails if the replacement target is not found):
+```bash
+apdf input.pdf output.pdf -r "foo=bar" -s
+```
+
+### Arguments
+
+* `input`: The source PDF file.
+* `output`: (Optional) The destination PDF file. Defaults to `output.pdf`.
+* `-r OLD=NEW`: Replace. The text replacement pair. You can supply this argument multiple times.
+* `-nopa`: No preserve advance. Do not compensate `TJ` text widths after making replacements.
+* `-s`: Strict. Fail if the original text is missing or the selected font cannot encode the new text.
+* `-ff FONT.ttf`: Fallback font. TrueType font to embed when the PDF's subset font lacks a glyph.
+* `-no-ff`: No font fallback. Reject missing glyphs instead of embedding a fallback font.

apdf-1.0/README.md

@@ -0,0 +1,66 @@
+# Another PDF editor
+
+**A-PDF** is a fast, command-line tool designed to replace Unicode and Hex text directly within PDF content streams. 
+
+## Features
+- **Direct Stream Replacement**: Modifies the underlying PDF streams directly for fast and precise text replacement.
+- **Unicode & Hex Support**: Replace text using standard string replacements that are automatically encoded to the document's fonts.
+- **Spacing Compensation**: Automatically compensates for `TJ` (Text Justification) width adjustments after text replacements to preserve document layout (can be disabled).
+- **Strict Mode**: Optionally fail replacements if text is missing or the font cannot encode the requested characters.
+- **Fallback Font Support**: Embed a custom TrueType font when the PDF's subset font lacks a glyph, or disable fallback entirely.
+
+## Installation
+
+You can run the tool directly using [uv](https://github.com/astral-sh/uv), which will automatically handle dependencies:
+```bash
+uv add apdf # or As a tool: uv tool install apdf
+# then Run it
+uv run apdf --help
+```
+Or simply use it in your standard Python environment.
+```bash
+pip install apdf
+
+# Run 
+apdf --help
+```
+
+## Usage
+
+```bash
+apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] input [output]
+```
+
+### Examples
+
+**Basic replacement:**
+```bash
+apdf input.pdf output.pdf -r "OldText=NewText"
+```
+
+**Multiple replacements:**
+```bash
+apdf document.pdf updated_document.pdf \
+    -r "Draft=Final" \
+    -r "2023=2024"
+```
+
+**Disable width compensation** (if characters are bunching up or spacing is incorrect):
+```bash
+apdf input.pdf output.pdf -r "foo=bar" -nopa
+```
+
+**Strict mode** (fails if the replacement target is not found):
+```bash
+apdf input.pdf output.pdf -r "foo=bar" -s
+```
+
+### Arguments
+
+* `input`: The source PDF file.
+* `output`: (Optional) The destination PDF file. Defaults to `output.pdf`.
+* `-r OLD=NEW`: Replace. The text replacement pair. You can supply this argument multiple times.
+* `-nopa`: No preserve advance. Do not compensate `TJ` text widths after making replacements.
+* `-s`: Strict. Fail if the original text is missing or the selected font cannot encode the new text.
+* `-ff FONT.ttf`: Fallback font. TrueType font to embed when the PDF's subset font lacks a glyph.
+* `-no-ff`: No font fallback. Reject missing glyphs instead of embedding a fallback font.

apdf-1.0/apdf/__init__.py

@@ -0,0 +1,5 @@
+from apdf.cli import main
+from apdf.engine import replace_pdf_text, replace_pdf_text_detailed
+from apdf.exceptions import FontEncodingError, PdfReplacementError
+from apdf.models import Replacement, ReplacementReport
+__all__ = ['FontEncodingError', 'PdfReplacementError', 'Replacement', 'ReplacementReport', 'main', 'replace_pdf_text', 'replace_pdf_text_detailed']

apdf-1.0/apdf/__main__.py

@@ -0,0 +1,2 @@
+from apdf.cli import main
+raise SystemExit(main())

apdf-1.0/apdf/cli.py

@@ -0,0 +1,73 @@
+from __future__ import annotations
+import argparse
+import sys
+from importlib.metadata import PackageNotFoundError, version
+from typing import Sequence
+from apdf.engine import replace_pdf_text_detailed
+from apdf.exceptions import PdfReplacementError
+from apdf.utils import _c, _supports_color, _BLUE, _BOLD, _CYAN, _DIM, _GRAY, _GREEN, _MAGENTA, _RED, _YELLOW
+
+def _installed_version() -> str:
+    try:
+        return version('apdf')
+    except PackageNotFoundError:
+        return '1.0'
+_BANNER = '\n_______       __________________________\n___    |      ___  __ \\__  __ \\__  ____' + '/\n__  /| |________  /_/ /_  / / /_  /_    \n_  ___ |/_____/  ____/_  /_/ /_  __/    \n/_/  |_|      /_/     /_____/ /_/   \n   \n'
+
+def _print_banner() -> None:
+    _ekiwktyjiqvscw = _installed_version()
+    if _supports_color():
+        _aomhlakkennlyy = _BANNER.strip('\n').splitlines()
+        _vajauyelrxjwor = [_RED, _RED, _BLUE, _BLUE, _CYAN]
+        for _orcjqqjrkxdmvn, _bhrcaadxxlskbv in enumerate(_aomhlakkennlyy):
+            _aolnsuvmdziujt = _vajauyelrxjwor[_orcjqqjrkxdmvn] if _orcjqqjrkxdmvn < len(_vajauyelrxjwor) else _CYAN
+            print(_c(_bhrcaadxxlskbv, _aolnsuvmdziujt, _BOLD), file=sys.stderr)
+    else:
+        print(_BANNER.strip('\n'), file=sys.stderr)
+    _inidpblknczlqe = _c('  Low-level PDF Text Rep' + 'lacer', _DIM)
+    _xjirsszckdbhxw = _c(f' v{_ekiwktyjiqvscw} ', _BOLD, _MAGENTA)
+    _kcaglkxhkhgurv = _c(' b' + 'y Ab' + 'od' + 'x9', _YELLOW, _BOLD)
+    print(f'{_inidpblknczlqe}{_xjirsszckdbhxw}{_kcaglkxhkhgurv}\n', file=sys.stderr)
+    print(_c('  ' + '─' * 52, _GRAY), file=sys.stderr)
+    print(file=sys.stderr)
+
+def _parse_replacements(values: Sequence[str]) -> dict[str, str]:
+    _nxodcjjpdthxce: dict[str, str] = {}
+    for _phdupmqsoiiqal in values:
+        if '=' not in _phdupmqsoiiqal:
+            raise ValueError('-r requires ' + 'OLD=NEW')
+        old, new = _phdupmqsoiiqal.split('=', 1)
+        if not old:
+            raise ValueError('OLD cannot be e' + 'mpty')
+        _nxodcjjpdthxce[old] = new
+    return _nxodcjjpdthxce
+
+def main(argv: Sequence[str] | None=None) -> int:
+    _print_banner()
+    if argv is None:
+        argv = sys.argv[1:]
+    _gnuqnzyfqlqvpo = argparse.ArgumentParser(description='Replac' + 'e Unicode and Hex text directly in PDF conte' + 'nt stream' + 's.')
+    _gnuqnzyfqlqvpo.add_argument('input', help='Input P' + 'D' + 'F')
+    _gnuqnzyfqlqvpo.add_argument('output', nargs='?', default='output.pdf', help='Outpu' + 't PD' + 'F')
+    _gnuqnzyfqlqvpo.add_argument('-r', action='append', default=[], metavar='OLD=NEW', dest='replace', help='Replace: Unicode rep' + 'lacement;' + ' may be supplied more than ' + 'once')
+    _gnuqnzyfqlqvpo.add_argument('-nopa', action='store_true', dest='no_preserve_advance', help='No preserve advance: Do not compensate TJ widths after repla' + 'cements')
+    _gnuqnzyfqlqvpo.add_argument('-s', action='store_true', dest='strict', help='Strict: Fail if tex' + 't is missing' + ' or the selected font cannot encode it')
+    _gnuqnzyfqlqvpo.add_argument('-ff', metavar='FONT.ttf', dest='fallback_font', help='Fallback font: TrueType font to ' + "embed when the PDF'" + 's subset font lacks a glyph; defaults to a common system sa' + 'ns-serif font')
+    _gnuqnzyfqlqvpo.add_argument('-no-ff', action='store_true', dest='no_font_fallback', help='No font fallback: R' + 'eject missing glyphs instead of embeddi' + 'ng a fallback font')
+    _hdmovsesznqako = _gnuqnzyfqlqvpo.parse_args(argv)
+    try:
+        replacements = _parse_replacements(_hdmovsesznqako.replace)
+        if not replacements:
+            _gnuqnzyfqlqvpo.error('provid' + 'e at least one ' + '-r OLD' + '=NEW')
+        _xhlsobehbsgotx = replace_pdf_text_detailed(_hdmovsesznqako.input, _hdmovsesznqako.output, replacements, preserve_advance=not _hdmovsesznqako.no_preserve_advance, strict=_hdmovsesznqako.strict, fallback_font=_hdmovsesznqako.fallback_font, font_fallback=not _hdmovsesznqako.no_font_fallback)
+    except (OSError, PdfReplacementError, ValueError) as _pwenbbrodrbzey:
+        _gnuqnzyfqlqvpo.exit(2, _c(f'error: {_pwenbbrodrbzey}\n', _RED))
+    except Exception as _pwenbbrodrbzey:
+        _gnuqnzyfqlqvpo.exit(2, _c(f'error: An unexpected error occurred: {type(_pwenbbrodrbzey).__name__}: {_pwenbbrodrbzey}\n', _RED))
+    print(_c(f'Replaced {_xhlsobehbsgotx.replacements} occurrence(s) in {_xhlsobehbsgotx.changed_streams}/{_xhlsobehbsgotx.scanned_streams} stream(s) in {_xhlsobehbsgotx.elapsed_seconds:.3f}s.', _GREEN))
+    if _xhlsobehbsgotx.missing:
+        print(_c('Not fo' + 'u' + 'nd: ' + ', '.join((repr(value) for value in _xhlsobehbsgotx.missing)), _RED))
+    if _xhlsobehbsgotx.encoding_failures:
+        print(_c(f'Skipped {len(_xhlsobehbsgotx.encoding_failures)} unencodable replacement(s).', _RED))
+    print(_c(f'Saved: {_hdmovsesznqako.output}', _GREEN, _BOLD))
+    return 0

apdf-1.0/apdf/codec.py

@@ -0,0 +1,169 @@
+from __future__ import annotations
+import sys
+from typing import Any, Mapping
+from fontTools.agl import UV2AGL
+from pypdf._font import Font
+from pypdf.generic import DictionaryObject
+from apdf.exceptions import FontEncodingError
+from apdf.utils import _deref
+
+class FontCodec:
+
+    def __init__(self, resource_name: str, font_object: DictionaryObject):
+        self.resource_name = resource_name
+        self.pdf_font = _deref(font_object)
+        self.font = Font.from_font_resource(self.pdf_font)
+        self._unicode_to_intermediate: dict[str, str] = {}
+        self._intermediate_to_bytes: dict[str, bytes] = {}
+        self._difference_glyphs: dict[int, str] = {}
+        self._embedded_glyphs: set[str] | None = None
+        self._build_inverse_maps()
+        self._load_glyph_inventory()
+
+    @property
+    def description(self) -> str:
+        _wozpkadibwzfdo = str(self.pdf_font.get('/Subtype', 'unknown'))
+        _jrcevktdeljeee = str(self.pdf_font.get('/BaseFont', 'unknown'))
+        return f'{self.resource_name} {_wozpkadibwzfdo} {_jrcevktdeljeee}'
+
+    def _build_inverse_maps(self) -> None:
+        for _sqmvsfamvtglze, _uxcpimgqqzwkij in self.font.character_map.items():
+            if isinstance(_sqmvsfamvtglze, str) and isinstance(_uxcpimgqqzwkij, str):
+                self._unicode_to_intermediate.setdefault(_uxcpimgqqzwkij, _sqmvsfamvtglze)
+        encoding = self.font.encoding
+        if isinstance(encoding, dict):
+            for _vxlaoowljmxybg, _gsujpyyvkhsxxv in encoding.items():
+                if isinstance(_vxlaoowljmxybg, int) and 0 <= _vxlaoowljmxybg <= 255 and isinstance(_gsujpyyvkhsxxv, str):
+                    self._intermediate_to_bytes.setdefault(_gsujpyyvkhsxxv, bytes((_vxlaoowljmxybg,)))
+
+    def _load_glyph_inventory(self) -> None:
+        encoding = _deref(self.pdf_font.get('/Encoding'))
+        if isinstance(encoding, DictionaryObject):
+            _mrxxjcwxuerymf: int | None = None
+            for _xcgndakfwknleb in encoding.get('/Differences', []):
+                _xcgndakfwknleb = _deref(_xcgndakfwknleb)
+                if isinstance(_xcgndakfwknleb, int):
+                    _mrxxjcwxuerymf = int(_xcgndakfwknleb)
+                elif _mrxxjcwxuerymf is not None:
+                    self._difference_glyphs[_mrxxjcwxuerymf] = str(_xcgndakfwknleb).lstrip('/')
+                    _mrxxjcwxuerymf += 1
+        _erhylqimslkpma = _deref(self.pdf_font.get('/FontDescriptor'))
+        _bdhfnisphgpnnu = _erhylqimslkpma.get('/CharSet') if _erhylqimslkpma else None
+        if _bdhfnisphgpnnu:
+            self._embedded_glyphs = {name for name in str(_bdhfnisphgpnnu).split('/') if name}
+
+    def _glyph_name_for_code(self, code: int) -> str | None:
+        if code in self._difference_glyphs:
+            return self._difference_glyphs[code]
+        encoding = self.font.encoding
+        if isinstance(encoding, dict):
+            _ffpiyggwzspapy = encoding.get(code)
+            if isinstance(_ffpiyggwzspapy, str) and len(_ffpiyggwzspapy) == 1:
+                return UV2AGL.get(ord(_ffpiyggwzspapy))
+        _pbpwakbjyfyhga = str(self.pdf_font.get('/Encoding', ''))
+        codec = {'/WinAnsiEncoding': 'cp1252', '/MacRomanEncoding': 'mac_roman'}.get(_pbpwakbjyfyhga, 'latin-1')
+        try:
+            _ltexlwkjjboggt = bytes((code,)).decode(codec)
+        except (UnicodeDecodeError, LookupError):
+            return None
+        return UV2AGL.get(ord(_ltexlwkjjboggt))
+
+    def _validate_embedded_glyphs(self, raw: bytes, visible: str) -> None:
+        _cmjxrgamnknxhq = str(self.pdf_font.get('/Subtype', ''))
+        if _cmjxrgamnknxhq == '/Type3':
+            encoding = self.font.encoding
+            if isinstance(encoding, dict):
+                for _ynczgtjbhzcjld in raw:
+                    _mbeamyadqmkcmb = encoding.get(_ynczgtjbhzcjld, chr(_ynczgtjbhzcjld))
+                    if _mbeamyadqmkcmb not in self.font.character_map:
+                        raise FontEncodingError(f'{self.description} has no explicit Type3 mapping for character code 0x{_ynczgtjbhzcjld:02X}')
+            if self.decode(raw) != visible:
+                raise FontEncodingError(f'{self.description} has no reversible glyph mapping for {visible!r}')
+            return
+        if self._embedded_glyphs is not None:
+            missing: list[str] = []
+            for _ynczgtjbhzcjld in raw:
+                _wglsywbrgcuwqn = self._glyph_name_for_code(_ynczgtjbhzcjld)
+                if _wglsywbrgcuwqn and _wglsywbrgcuwqn not in self._embedded_glyphs:
+                    missing.append(_wglsywbrgcuwqn)
+            if missing:
+                names = ', '.join(sorted(set(missing)))
+                raise FontEncodingError(f'{self.description} embedded subset lacks glyph(s): {names}')
+        if self.decode(raw) != visible:
+            raise FontEncodingError(f'{self.description} does not round-trip replacement {visible!r}')
+
+    def decode(self, raw: bytes) -> str:
+        encoding = self.font.encoding
+        if isinstance(encoding, str):
+            try:
+                _dwjqepqdmzpydx = raw.decode(encoding, errors='surrogatepass')
+            except (LookupError, UnicodeError):
+                _aiyhqgkozvuxvl = 'utf-16-be' if len(raw) % 2 == 0 else 'latin-1'
+                _dwjqepqdmzpydx = raw.decode(_aiyhqgkozvuxvl, errors='replace')
+        else:
+            _dwjqepqdmzpydx = ''.join((encoding.get(byte, chr(byte)) for byte in raw))
+        return ''.join((self.font.character_map.get(character, character) for character in _dwjqepqdmzpydx))
+
+    @staticmethod
+    def _greedy_map(text: str, mapping: Mapping[str, str]) -> str:
+        if not mapping:
+            return text
+        _taysbvduzlwvpf = sorted(mapping, key=len, reverse=True)
+        output: list[str] = []
+        _rjciwatenvnubt = 0
+        while _rjciwatenvnubt < len(text):
+            for key in _taysbvduzlwvpf:
+                if key and text.startswith(key, _rjciwatenvnubt):
+                    output.append(mapping[key])
+                    _rjciwatenvnubt += len(key)
+                    break
+            else:
+                output.append(text[_rjciwatenvnubt])
+                _rjciwatenvnubt += 1
+        return ''.join(output)
+
+    def encode(self, visible: str) -> bytes:
+        _mqcsiaerslqqcw = self._greedy_map(visible, self._unicode_to_intermediate)
+        encoding = self.font.encoding
+        if isinstance(encoding, str):
+            try:
+                _zqiehzxforrqfg = _mqcsiaerslqqcw.encode(encoding, errors='strict')
+            except (LookupError, UnicodeError) as _ethzaketqjwtcf:
+                raise FontEncodingError(f'{self.description} cannot encode {visible!r}') from _ethzaketqjwtcf
+            self._validate_embedded_glyphs(_zqiehzxforrqfg, visible)
+            return _zqiehzxforrqfg
+        _golytujyyqqjgy = sorted(self._intermediate_to_bytes, key=len, reverse=True)
+        _npwxcsvwxxfsgx = bytearray()
+        _pnqijbrslweiwd = 0
+        while _pnqijbrslweiwd < len(_mqcsiaerslqqcw):
+            for key in _golytujyyqqjgy:
+                if key and _mqcsiaerslqqcw.startswith(key, _pnqijbrslweiwd):
+                    _npwxcsvwxxfsgx.extend(self._intermediate_to_bytes[key])
+                    _pnqijbrslweiwd += len(key)
+                    break
+            else:
+                raise FontEncodingError(f'{self.description} cannot encode character {_mqcsiaerslqqcw[_pnqijbrslweiwd]!r} in {visible!r}')
+        _zqiehzxforrqfg = bytes(_npwxcsvwxxfsgx)
+        self._validate_embedded_glyphs(_zqiehzxforrqfg, visible)
+        return _zqiehzxforrqfg
+
+    def width(self, visible: str) -> float:
+        try:
+            width_method = getattr(self.font, 'get_text_width', None)
+            if width_method is None:
+                width_method = getattr(self.font, 'text_width')
+            return float(width_method(visible))
+        except Exception:
+            return 0.0
+
+def _font_codecs(resources: Any) -> dict[str, FontCodec]:
+    resources = _deref(resources)
+    fonts = _deref(resources.get('/Font', {})) if resources else {}
+    result: dict[str, FontCodec] = {}
+    for name, font_ref in getattr(fonts, 'items', lambda: [])():
+        resource_name = str(name)
+        try:
+            result[resource_name] = FontCodec(resource_name, _deref(font_ref))
+        except Exception as exc:
+            print(f'Warning: Skipping unreadable font {resource_name}: {exc}', file=sys.stderr)
+    return result

apdf-1.0/apdf/engine.py

@@ -0,0 +1,125 @@
+from __future__ import annotations
+import os
+import sys
+import tempfile
+import time
+from pathlib import Path
+from typing import Any, Iterable, Mapping, Sequence
+from pypdf import PdfReader, PdfWriter
+from pypdf.errors import DependencyError
+from pypdf.generic import ArrayObject, ContentStream, StreamObject
+from apdf.codec import _font_codecs
+from apdf.exceptions import PdfReplacementError, PdfDependencyError, PdfPermissionError, PdfFileNotFoundError
+from apdf.fallback import FallbackFontRegistry
+from apdf.models import Replacement, ReplacementReport
+from apdf.operations import _rewrite_operations
+from apdf.utils import _deref, _object_key, _c, _BLUE
+
+def _set_decoded_stream_data(stream: StreamObject, data: bytes) -> None:
+    try:
+        stream.set_data(data)
+    except Exception as _uhoyuxylmrtgqf:
+        raise PdfReplacementError('Cannot rewrite a content s' + 'tream with its current PDF ' + 'f' + 'ilters') from _uhoyuxylmrtgqf
+
+def _rewrite_stream(stream: StreamObject, pdf: PdfWriter, resources: Any, replacements: Sequence[Replacement], preserve_advance: bool, report: ReplacementReport, matched: set[str], fallback_registry: FallbackFontRegistry) -> None:
+    report.scanned_streams += 1
+    content = ContentStream(stream, pdf)
+    operations = content.operations
+    codecs = _font_codecs(resources)
+    count = _rewrite_operations(operations, codecs, replacements, preserve_advance, report, matched, lambda original, size, visible: fallback_registry.resolve(original, size, visible, resources))
+    if count:
+        content.operations = operations
+        _set_decoded_stream_data(stream, content.get_data())
+        report.changed_streams += 1
+
+def _content_streams(owner: Any) -> Iterable[StreamObject]:
+    _ypkhvskndrbswp = _deref(owner.get('/Contents'))
+    if _ypkhvskndrbswp is None:
+        return
+    if isinstance(_ypkhvskndrbswp, (list, ArrayObject)):
+        for _ebfsolxzfkohsg in _ypkhvskndrbswp:
+            _qqwnilrljvsekr = _deref(_ebfsolxzfkohsg)
+            if isinstance(_qqwnilrljvsekr, StreamObject):
+                yield _qqwnilrljvsekr
+    elif isinstance(_ypkhvskndrbswp, StreamObject):
+        yield _ypkhvskndrbswp
+
+def _rewrite_forms(resources: Any, pdf: PdfWriter, replacements: Sequence[Replacement], preserve_advance: bool, report: ReplacementReport, matched: set[str], visited: set[tuple[Any, ...]], fallback_registry: FallbackFontRegistry) -> None:
+    resources = _deref(resources)
+    xobjects = _deref(resources.get('/XObject', {})) if resources else {}
+    for _, reference in getattr(xobjects, 'items', lambda: [])():
+        form = _deref(reference)
+        if not isinstance(form, StreamObject) or form.get('/Subtype') != '/Form':
+            continue
+        key = _object_key(form)
+        if key in visited:
+            continue
+        visited.add(key)
+        form_resources = _deref(form.get('/Resources')) or resources
+        _rewrite_stream(form, pdf, form_resources, replacements, preserve_advance, report, matched, fallback_registry)
+        _rewrite_forms(form_resources, pdf, replacements, preserve_advance, report, matched, visited, fallback_registry)
+
+def replace_pdf_text_detailed(input_pdf: str | os.PathLike[str], output_pdf: str | os.PathLike[str], replacements: Mapping[str, str], *, preserve_advance: bool=True, strict: bool=False, fallback_font: str | os.PathLike[str] | None=None, font_fallback: bool=True) -> ReplacementReport:
+    _tuztsnbsazjejg = time.perf_counter()
+    _usixbitweyswqw = [Replacement(str(old), str(new)) for old, new in replacements.items() if old]
+    if not _usixbitweyswqw:
+        raise ValueError('At least one non-emp' + 'ty source string is r' + 'equired')
+    _bbqveuuofmwyiv = Path(input_pdf)
+    _akmbommssynhbk = Path(output_pdf)
+    if not _bbqveuuofmwyiv.is_file():
+        raise PdfFileNotFoundError(f'File not found: {_bbqveuuofmwyiv}')
+    _akmbommssynhbk.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        _eeutrcnebgnywy = PdfReader(_bbqveuuofmwyiv, strict=False)
+    except DependencyError as _cptutzbiolqyrf:
+        raise PdfDependencyError(f"Missing dependency for encrypted PDF: {_cptutzbiolqyrf}\nPlease install it, e.g., 'uv pip install cryptography'") from _cptutzbiolqyrf
+    except PermissionError as _cptutzbiolqyrf:
+        raise PdfPermissionError(f'Permission denied when opening {_bbqveuuofmwyiv}. The PDF might be opened by another application.') from _cptutzbiolqyrf
+    if _eeutrcnebgnywy.is_encrypted:
+        raise PdfReplacementError('Encrypted PDFs are not supp' + 'orted without a pass' + 'word')
+    writer = PdfWriter(clone_from=_eeutrcnebgnywy)
+    _ethuwapkqidjlz = FallbackFontRegistry(writer, explicit_font=fallback_font, enabled=font_fallback)
+    _qfzabxnfntnkmj = ReplacementReport(pages=len(writer.pages))
+    _drcfelcnltzfpi: set[str] = set()
+    _jsfnwqqaaosxwm: set[tuple[Any, ...]] = set()
+    for _uccdolnszdqhxp, _aaggvlekoobqpv in enumerate(writer.pages, start=1):
+        print(_c(f'Processing page {_uccdolnszdqhxp}/{_qfzabxnfntnkmj.pages}', _BLUE), file=sys.stderr)
+        _mvvirxvkkdchtt = _deref(_aaggvlekoobqpv.get('/Resources', {}))
+        for _rnlzqjzpzbzjwd in _content_streams(_aaggvlekoobqpv):
+            key = _object_key(_rnlzqjzpzbzjwd)
+            if key in _jsfnwqqaaosxwm:
+                continue
+            _jsfnwqqaaosxwm.add(key)
+            _rewrite_stream(_rnlzqjzpzbzjwd, writer, _mvvirxvkkdchtt, _usixbitweyswqw, preserve_advance, _qfzabxnfntnkmj, _drcfelcnltzfpi, _ethuwapkqidjlz)
+        _rewrite_forms(_mvvirxvkkdchtt, writer, _usixbitweyswqw, preserve_advance, _qfzabxnfntnkmj, _drcfelcnltzfpi, _jsfnwqqaaosxwm, _ethuwapkqidjlz)
+    _ethuwapkqidjlz.finalize()
+    _qfzabxnfntnkmj.missing = [rule.old for rule in _usixbitweyswqw if rule.old not in _drcfelcnltzfpi]
+    _qfzabxnfntnkmj.elapsed_seconds = time.perf_counter() - _tuztsnbsazjejg
+    if strict and (_qfzabxnfntnkmj.missing or _qfzabxnfntnkmj.encoding_failures):
+        _baknxbpjcowtlf = []
+        if _qfzabxnfntnkmj.missing:
+            _baknxbpjcowtlf.append(f'not found: {_qfzabxnfntnkmj.missing!r}')
+        if _qfzabxnfntnkmj.encoding_failures:
+            _baknxbpjcowtlf.append(f'encoding failures: {_qfzabxnfntnkmj.encoding_failures!r}')
+        raise PdfReplacementError('; '.join(_baknxbpjcowtlf))
+    _hroujqvfvrqzkv: str | None = None
+    try:
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', prefix=f'.{_akmbommssynhbk.name}.', suffix='.tmp', dir=_akmbommssynhbk.parent, delete=False) as _ssuyqgnyzggkki:
+                _hroujqvfvrqzkv = _ssuyqgnyzggkki.name
+                writer.write(_ssuyqgnyzggkki)
+            _stzlaxcsrisprv = PdfReader(_hroujqvfvrqzkv, strict=False)
+            if len(_stzlaxcsrisprv.pages) != _qfzabxnfntnkmj.pages:
+                raise PdfReplacementError('Output ve' + 'rification found a page-count mism' + 'a' + 'tch')
+            os.replace(_hroujqvfvrqzkv, _akmbommssynhbk)
+            _hroujqvfvrqzkv = None
+        except PermissionError as _cptutzbiolqyrf:
+            raise PdfPermissionError(f'Permission denied when saving to {_akmbommssynhbk}. The PDF might be opened by another application.') from _cptutzbiolqyrf
+    finally:
+        if _hroujqvfvrqzkv and os.path.exists(_hroujqvfvrqzkv):
+            os.unlink(_hroujqvfvrqzkv)
+    _qfzabxnfntnkmj.elapsed_seconds = time.perf_counter() - _tuztsnbsazjejg
+    return _qfzabxnfntnkmj
+
+def replace_pdf_text(input_pdf: str | os.PathLike[str], output_pdf: str | os.PathLike[str], replacements: Mapping[str, str], **kwargs: Any) -> int:
+    return replace_pdf_text_detailed(input_pdf, output_pdf, replacements, **kwargs).replacements

apdf-1.0/apdf/exceptions.py

@@ -0,0 +1,20 @@
+class PdfReplacementError(RuntimeError):
+    pass
+
+class FontEncodingError(PdfReplacementError):
+    pass
+
+class PdfDependencyError(PdfReplacementError):
+    pass
+
+class PdfPermissionError(PdfReplacementError):
+    pass
+
+class PdfFileNotFoundError(PdfReplacementError):
+    pass
+
+class PdfPasswordError(PdfReplacementError):
+    pass
+
+class PdfMalformedError(PdfReplacementError):
+    pass