apdf 1.0__py3-none-any.whl

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/__main__.py

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

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/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/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/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

apdf/fallback.py

@@ -0,0 +1,221 @@
+from __future__ import annotations
+import os
+import re
+import sys
+from io import BytesIO
+from pathlib import Path
+from typing import Any
+from fontTools.subset import Options, Subsetter
+from fontTools.ttLib import TTFont
+from pypdf import PdfWriter
+from pypdf.generic import ArrayObject, DecodedStreamObject, DictionaryObject, FloatObject, NameObject, NumberObject, TextStringObject
+from apdf.codec import FontCodec
+from apdf.exceptions import FontEncodingError
+from apdf.utils import _deref
+
+def _pdf_name(value: str) -> NameObject:
+    _hmziujqhiutwmb = re.sub('[^A-Za-z0-9_.+-]', '', value) or 'Fallback'
+    return NameObject('/' + _hmziujqhiutwmb)
+
+def _scaled(value: float, units_per_em: int) -> int:
+    return int(round(float(value) * 1000.0 / units_per_em))
+
+def _name_record(font: TTFont, name_id: int) -> str | None:
+    _yfxwfsgwajhylz = font.get('name')
+    if _yfxwfsgwajhylz is None:
+        return None
+    for _sjoqzgtyblyxac in _yfxwfsgwajhylz.names:
+        if _sjoqzgtyblyxac.nameID == name_id:
+            try:
+                return _sjoqzgtyblyxac.toUnicode()
+            except Exception:
+                continue
+    return None
+
+def _candidate_fonts(bold: bool) -> list[Path]:
+    _izygplgavcxncm = os.environ.get('APDF_FALLBACK_FONT')
+    _ixuasrqxiznlxq: list[Path] = [Path(_izygplgavcxncm)] if _izygplgavcxncm else []
+    if sys.platform == 'win32':
+        _xmssfxrkddtrlv = Path(os.environ.get('WINDIR', 'C:\\Windows'), 'Fonts')
+        names = ['arialbd.ttf', 'segoeuib.ttf', 'calibrib.ttf'] if bold else ['arial.ttf', 'segoeui.ttf', 'calibri.ttf']
+        _ixuasrqxiznlxq.extend((_xmssfxrkddtrlv / name for name in names))
+    elif sys.platform == 'darwin':
+        names = ['/Syste' + 'm/Library/F' + 'onts/Supple' + 'mental/Arial Bold.ttf' if bold else '/System/Library/Fonts/Supplemental/Arial.ttf', '/System/Library/Fonts/Supplemental/DejaVuSans-Bold.ttf' if bold else '/System/Library/Fonts/Supplemental/DejaVuSans.ttf']
+        _ixuasrqxiznlxq.extend((Path(name) for name in names))
+    else:
+        names = ['/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf' if bold else '/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf', '/usr/share/fonts/truetype/liberation2/LiberationSans-Bold.ttf' if bold else '/usr/share/fonts/truetype/liberation2/LiberationSans-Regular.ttf']
+        _ixuasrqxiznlxq.extend((Path(name) for name in names))
+    return _ixuasrqxiznlxq
+
+def find_fallback_font(explicit: str | os.PathLike[str] | None, *, bold: bool) -> Path | None:
+    if explicit:
+        path = Path(explicit)
+        if not path.is_file():
+            raise FileNotFoundError(f'Fallback font not found: {path}')
+        return path
+    return next((path for path in _candidate_fonts(bold) if path.is_file()), None)
+
+class EmbeddedFallbackCodec:
+
+    def __init__(self, writer: PdfWriter, font_path: Path, resource_name: str) -> None:
+        self.resource_name = resource_name
+        self.font_path = font_path
+        self._font_bytes = font_path.read_bytes()
+        self._ttfont = TTFont(BytesIO(self._font_bytes), recalcBBoxes=False, recalcTimestamp=False)
+        os2 = self._ttfont.get('OS/2')
+        if os2 is not None and int(getattr(os2, 'fsType', 0)) & 2:
+            raise FontEncodingError(f'{font_path} forbids font embedding in its OS/2 licensing flags')
+        self._cmap = self._ttfont.getBestCmap() or {}
+        self._glyph_order = self._ttfont.getGlyphOrder()
+        self._glyph_ids = {name: index for index, name in enumerate(self._glyph_order)}
+        self._units_per_em = int(self._ttfont['head'].unitsPerEm)
+        self._hmtx = self._ttfont['hmtx'].metrics
+        self._used: dict[int, str] = {}
+        self._writer = writer
+        self._to_unicode = DecodedStreamObject()
+        self._cid_font = DictionaryObject()
+        self._font_file_reference = None
+        self._font_reference = self._build_pdf_font()
+
+    @property
+    def description(self) -> str:
+        return f'{self.resource_name} embedded fallback {self.font_path.name}'
+
+    def decode(self, raw: bytes) -> str:
+        if len(raw) % 2:
+            return '�'
+        reverse = {gid: character for gid, character in self._used.items()}
+        return ''.join((reverse.get(int.from_bytes(raw[pos:pos + 2], 'big'), '�') for pos in range(0, len(raw), 2)))
+
+    def encode(self, visible: str) -> bytes:
+        output = bytearray()
+        for _xpzglmigkwxpji in visible:
+            _qhsmhishbjnxkr = self._cmap.get(ord(_xpzglmigkwxpji))
+            if _qhsmhishbjnxkr is None:
+                raise FontEncodingError(f'{self.description} lacks glyph {_xpzglmigkwxpji!r}')
+            _szwztsgxjmbkva = self._glyph_ids[_qhsmhishbjnxkr]
+            if _szwztsgxjmbkva > 65535:
+                raise FontEncodingError(f'{self.description} glyph ID exceeds Identity-H range')
+            _sbszocqtdshpvf = self._used.get(_szwztsgxjmbkva)
+            if _sbszocqtdshpvf is not None and _sbszocqtdshpvf != _xpzglmigkwxpji:
+                raise FontEncodingError(f'{self.description} maps {_sbszocqtdshpvf!r} and {_xpzglmigkwxpji!r} to one glyph')
+            self._used[_szwztsgxjmbkva] = _xpzglmigkwxpji
+            output.extend(_szwztsgxjmbkva.to_bytes(2, 'big'))
+        return bytes(output)
+
+    def width(self, visible: str) -> float:
+        width = 0.0
+        for _nixsgzlzmkhjnc in visible:
+            _wbdtruznlyhlyg = self._cmap.get(ord(_nixsgzlzmkhjnc))
+            if _wbdtruznlyhlyg is None:
+                continue
+            _plmbwxcnzdpbud, _ = self._hmtx[_wbdtruznlyhlyg]
+            width += _scaled(_plmbwxcnzdpbud, self._units_per_em)
+        return width
+
+    def install(self, resources: Any) -> None:
+        resources = _deref(resources)
+        _lvcoyogyohfoxn = _deref(resources.get('/Font')) if resources else None
+        if _lvcoyogyohfoxn is None:
+            _lvcoyogyohfoxn = DictionaryObject()
+            resources[NameObject('/Font')] = _lvcoyogyohfoxn
+        _lvcoyogyohfoxn[NameObject(self.resource_name)] = self._font_reference
+
+    def finalize(self) -> None:
+        _fjktcramkxbljm = []
+        _mvlnscnvxxlgqh = ArrayObject()
+        for _noqwzetnpjngoo, _rralsgxsckinba in sorted(self._used.items()):
+            _rfyxzfjqgrktuz = _rralsgxsckinba.encode('utf-16-be').hex().upper()
+            _fjktcramkxbljm.append(f'<{_noqwzetnpjngoo:04X}> <{_rfyxzfjqgrktuz}>')
+            _nzruwniixwvedf = self._glyph_order[_noqwzetnpjngoo]
+            _rntiwezcxsuxvl, _ = self._hmtx[_nzruwniixwvedf]
+            _mvlnscnvxxlgqh.extend([NumberObject(_noqwzetnpjngoo), ArrayObject([NumberObject(_scaled(_rntiwezcxsuxvl, self._units_per_em))])])
+        _tormfuuxkmigib: list[str] = []
+        for start in range(0, len(_fjktcramkxbljm), 100):
+            _hawfpkgtuzilqg = _fjktcramkxbljm[start:start + 100]
+            _tormfuuxkmigib.append(f'{len(_hawfpkgtuzilqg)} beginbfchar\n' + '\n'.join(_hawfpkgtuzilqg) + ('\n' + 'endbf' + 'ch' + 'ar'))
+        _qdnxoepgwqdxdj = '/CIDInit /ProcSet findresource begin\n12 dict begin\nbegincmap\n/CIDSystemInfo << /Registry (Adobe) /Ordering (UCS) /Supplement 0 >> def\n/CMapName /APDF-Identity-UCS def\n/CMapType 2 def\n1 begincodespacerange\n<0000> ' + '<FFFF>\nendcodespacerange\n' + '\n'.join(_tormfuuxkmigib) + ('\nendcmap\nCMapName currentdict /CMap define' + 'resou' + 'rce pop\nend' + '\nend\n')
+        self._to_unicode.set_data(_qdnxoepgwqdxdj.encode('ascii'))
+        self._cid_font[NameObject('/W')] = _mvlnscnvxxlgqh
+        _hevakmfgjjuizx = DecodedStreamObject()
+        _atwivagthmenfm = self._subset_font_bytes()
+        _hevakmfgjjuizx.set_data(_atwivagthmenfm)
+        _hevakmfgjjuizx[NameObject('/Length1')] = NumberObject(len(_atwivagthmenfm))
+        self._writer._replace_object(self._font_file_reference, _hevakmfgjjuizx.flate_encode())
+
+    def _subset_font_bytes(self) -> bytes:
+        font = TTFont(BytesIO(self._font_bytes), recalcBBoxes=False, recalcTimestamp=False)
+        options = Options()
+        options.retain_gids = True
+        options.notdef_glyph = True
+        options.notdef_outline = True
+        options.drop_tables.append('meta')
+        _rpdajnthevqknr = Subsetter(options=options)
+        _rpdajnthevqknr.populate(unicodes={ord(character) for character in self._used.values()})
+        _rpdajnthevqknr.subset(font)
+        output = BytesIO()
+        font.save(output, reorderTables=True)
+        font.close()
+        return output.getvalue()
+
+    def _build_pdf_font(self):
+        head = self._ttfont['head']
+        hhea = self._ttfont['hhea']
+        os2 = self._ttfont.get('OS/2')
+        post = self._ttfont.get('post')
+        postscript_name = _name_record(self._ttfont, 6) or self.font_path.stem
+        base_font = _pdf_name('APDF+' + postscript_name)
+        self._font_file_reference = self._writer._add_object(DecodedStreamObject())
+        flags = 32
+        if post is not None and getattr(post, 'isFixedPitch', 0):
+            flags |= 1
+        italic_angle = float(getattr(post, 'italicAngle', 0.0)) if post else 0.0
+        if italic_angle:
+            flags |= 64
+        weight = int(getattr(os2, 'usWeightClass', 400)) if os2 else 400
+        if weight >= 600:
+            flags |= 262144
+        descriptor = DictionaryObject({NameObject('/Type'): NameObject('/FontDescriptor'), NameObject('/FontName'): base_font, NameObject('/Flags'): NumberObject(flags), NameObject('/FontBBox'): ArrayObject([NumberObject(_scaled(head.xMin, self._units_per_em)), NumberObject(_scaled(head.yMin, self._units_per_em)), NumberObject(_scaled(head.xMax, self._units_per_em)), NumberObject(_scaled(head.yMax, self._units_per_em))]), NameObject('/ItalicAngle'): FloatObject(italic_angle), NameObject('/Ascent'): NumberObject(_scaled(hhea.ascent, self._units_per_em)), NameObject('/Descent'): NumberObject(_scaled(hhea.descent, self._units_per_em)), NameObject('/CapHeight'): NumberObject(_scaled(getattr(os2, 'sCapHeight', hhea.ascent), self._units_per_em)), NameObject('/StemV'): NumberObject(120 if weight >= 600 else 80), NameObject('/FontFile2'): self._font_file_reference})
+        descriptor_ref = self._writer._add_object(descriptor)
+        cid_system = DictionaryObject({NameObject('/Registry'): TextStringObject('Adobe'), NameObject('/Ordering'): TextStringObject('Identity'), NameObject('/Supplement'): NumberObject(0)})
+        default_advance, _ = self._hmtx[self._glyph_order[0]]
+        self._cid_font.update({NameObject('/Type'): NameObject('/Font'), NameObject('/Subtype'): NameObject('/CIDFontType2'), NameObject('/BaseFont'): base_font, NameObject('/CIDSystemInfo'): cid_system, NameObject('/FontDescriptor'): descriptor_ref, NameObject('/DW'): NumberObject(_scaled(default_advance, self._units_per_em)), NameObject('/CIDToGIDMap'): NameObject('/Identity')})
+        cid_ref = self._writer._add_object(self._cid_font)
+        to_unicode_ref = self._writer._add_object(self._to_unicode)
+        type0 = DictionaryObject({NameObject('/Type'): NameObject('/Font'), NameObject('/Subtype'): NameObject('/Type0'), NameObject('/BaseFont'): base_font, NameObject('/Encoding'): NameObject('/Identity-H'), NameObject('/DescendantFonts'): ArrayObject([cid_ref]), NameObject('/ToUnicode'): to_unicode_ref})
+        return self._writer._add_object(type0)
+
+class FallbackFontRegistry:
+
+    def __init__(self, writer: PdfWriter, explicit_font: str | os.PathLike[str] | None, enabled: bool) -> None:
+        self.writer = writer
+        self.explicit_font = explicit_font
+        self.enabled = enabled
+        self._codecs: dict[bool, EmbeddedFallbackCodec] = {}
+
+    @staticmethod
+    def _wants_bold(original: FontCodec, font_size: float) -> bool:
+        _bqsmocbsaxuosd = _deref(original.pdf_font.get('/FontDescriptor'))
+        _lyczhenzhgwons = int(_bqsmocbsaxuosd.get('/FontWeight', 0)) if _bqsmocbsaxuosd else 0
+        name = str(original.pdf_font.get('/BaseFont', '')).lower()
+        return _lyczhenzhgwons >= 600 or 'bold' in name or 'semibold' in name or (font_size >= 18)
+
+    def resolve(self, original: FontCodec, font_size: float, visible: str, resources: Any) -> EmbeddedFallbackCodec | None:
+        if not self.enabled:
+            return None
+        bold = self._wants_bold(original, font_size)
+        codec = self._codecs.get(bold)
+        if codec is None:
+            path = find_fallback_font(self.explicit_font, bold=bold)
+            if path is None:
+                return None
+            resource_name = '/APDFB' if bold else '/APDFR'
+            codec = EmbeddedFallbackCodec(self.writer, path, resource_name)
+            self._codecs[bold] = codec
+        codec.encode(visible)
+        codec.install(resources)
+        return codec
+
+    def finalize(self) -> None:
+        for codec in self._codecs.values():
+            codec.finalize()

apdf/models.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import TYPE_CHECKING, Any
+if TYPE_CHECKING:
+    from apdf.codec import FontCodec
+
+@dataclass(frozen=True)
+class Replacement:
+    old: str
+    new: str
+
+@dataclass
+class ReplacementReport:
+    replacements: int = 0
+    changed_streams: int = 0
+    scanned_streams: int = 0
+    pages: int = 0
+    elapsed_seconds: float = 0.0
+    missing: list[str] = field(default_factory=list)
+    encoding_failures: list[str] = field(default_factory=list)
+
+@dataclass(frozen=True)
+class TextState:
+    codec: FontCodec
+    font_size: float
+    character_spacing: float
+    word_spacing: float
+
+@dataclass
+class ShowOperation:
+    index: int
+    operator: bytes
+    operands: list[Any]
+    state: TextState
+    raw: bytes
+    text: str
+    adjustment: float
+
+@dataclass
+class PositionedShow:
+    show: ShowOperation
+    x: float
+    y: float
+
+@dataclass(frozen=True)
+class FontSwitch:
+    start_index: int
+    end_index: int
+    original_font: str
+    fallback_font: str
+    font_size: float

apdf/operations.py

@@ -0,0 +1,384 @@
+from __future__ import annotations
+import sys
+from typing import Any, Callable, Mapping, Sequence
+from pypdf.generic import ArrayObject, ByteStringObject, FloatObject, NameObject, NumberObject
+from apdf.codec import FontCodec, _font_codecs
+from apdf.exceptions import FontEncodingError
+from apdf.models import PositionedShow, Replacement, ReplacementReport, FontSwitch, ShowOperation, TextState
+from apdf.utils import _is_pdf_string, _raw_bytes
+TEXT_SHOW = {b'Tj', b'TJ', b"'", b'"'}
+FallbackResolver = Callable[[FontCodec, float, str], Any | None]
+
+def _encode_replacement(original: FontCodec, visible: str, font_size: float, fallback_resolver: FallbackResolver | None) -> tuple[bytes, Any]:
+    try:
+        return (original.encode(visible), original)
+    except FontEncodingError:
+        if fallback_resolver is None:
+            raise
+        _leccpwednlbhqd = fallback_resolver(original, font_size, visible)
+        if _leccpwednlbhqd is None:
+            raise
+        return (_leccpwednlbhqd.encode(visible), _leccpwednlbhqd)
+
+def _show_payload(index: int, operator: bytes, operands: list[Any], state: TextState) -> ShowOperation | None:
+    _pxjnxhbjhdttlz: list[Any]
+    adjustment = 0.0
+    if operator == b'TJ':
+        if not operands or not isinstance(operands[0], (list, ArrayObject)):
+            return None
+        _pxjnxhbjhdttlz = [item for item in operands[0] if _is_pdf_string(item)]
+        adjustment = sum((float(item) for item in operands[0] if isinstance(item, (int, float, NumberObject, FloatObject))))
+    elif operator == b'"':
+        _pxjnxhbjhdttlz = operands[2:3]
+    else:
+        _pxjnxhbjhdttlz = operands[0:1]
+    try:
+        raw = b''.join((_raw_bytes(item) for item in _pxjnxhbjhdttlz))
+    except (TypeError, UnicodeError):
+        return None
+    return ShowOperation(index=index, operator=operator, operands=operands, state=state, raw=raw, text=state.codec.decode(raw), adjustment=adjustment)
+
+def _apply_replacements(text: str, replacements: Sequence[Replacement]) -> tuple[str, int, set[str]]:
+    _kjwwlacckuirmf = text
+    count = 0
+    _lbujiavuwardtf: set[str] = set()
+    for _fjfhutvfdmztxh in replacements:
+        _wpcsovaioqsrtt = _kjwwlacckuirmf.count(_fjfhutvfdmztxh.old)
+        if _wpcsovaioqsrtt:
+            _kjwwlacckuirmf = _kjwwlacckuirmf.replace(_fjfhutvfdmztxh.old, _fjfhutvfdmztxh.new)
+            count += _wpcsovaioqsrtt
+            _lbujiavuwardtf.add(_fjfhutvfdmztxh.old)
+    return (_kjwwlacckuirmf, count, _lbujiavuwardtf)
+
+def _compensation(show: Sequence[ShowOperation], old: str, new: str) -> float:
+    state = show[0].state
+    adjustment = sum((item.adjustment for item in show))
+    adjustment += state.codec.width(new) - state.codec.width(old)
+    if state.font_size:
+        adjustment += (len(new) - len(old)) * state.character_spacing / state.font_size * 1000.0
+        adjustment += (new.count(' ') - old.count(' ')) * state.word_spacing / state.font_size * 1000.0
+    return adjustment
+
+def _set_show_text(operations: list[tuple[list[Any], bytes]], show: Sequence[ShowOperation], encoded: bytes, old_text: str, new_text: str, preserve_advance: bool, replacement_codec: Any, switches: list[FontSwitch], codec_overrides: dict[int, Any]) -> None:
+    _obhzghgyiiqyxs = show[0]
+    _ozvxtrglfaamca = ByteStringObject(encoded)
+    adjustment = _compensation(show, old_text, new_text) if preserve_advance else 0.0
+    if _obhzghgyiiqyxs.operator in (b'Tj', b'TJ'):
+        _irzgfpcveocgno = ArrayObject([_ozvxtrglfaamca])
+        if preserve_advance and abs(adjustment) >= 0.0001:
+            _irzgfpcveocgno.append(FloatObject(round(adjustment, 4)))
+        operations[_obhzghgyiiqyxs.index] = ([_irzgfpcveocgno], b'TJ')
+    elif _obhzghgyiiqyxs.operator == b"'":
+        _obhzghgyiiqyxs.operands[0] = _ozvxtrglfaamca
+    elif _obhzghgyiiqyxs.operator == b'"':
+        _obhzghgyiiqyxs.operands[2] = _ozvxtrglfaamca
+    if replacement_codec is not _obhzghgyiiqyxs.state.codec:
+        end_index = max((item.index for item in show))
+        switches.append(FontSwitch(start_index=_obhzghgyiiqyxs.index, end_index=end_index, original_font=_obhzghgyiiqyxs.state.codec.resource_name, fallback_font=replacement_codec.resource_name, font_size=_obhzghgyiiqyxs.state.font_size))
+        codec_overrides[_obhzghgyiiqyxs.index] = replacement_codec
+    for _kysulfzczktzyg in show[1:]:
+        if _kysulfzczktzyg.operator == b'TJ':
+            operations[_kysulfzczktzyg.index] = ([ArrayObject()], b'TJ')
+        elif _kysulfzczktzyg.operator == b'Tj':
+            _kysulfzczktzyg.operands[0] = ByteStringObject(b'')
+
+def _rewrite_operations(operations: list[tuple[list[Any], bytes]], codecs: Mapping[str, FontCodec], replacements: Sequence[Replacement], preserve_advance: bool, report: ReplacementReport, matched: set[str], fallback_resolver: FallbackResolver | None=None) -> int:
+    current: FontCodec | None = None
+    font_size = 0.0
+    character_spacing = 0.0
+    word_spacing = 0.0
+    graphics_stack: list[tuple[FontCodec | None, float, float, float]] = []
+    pending: list[ShowOperation] = []
+    changed = 0
+    switches: list[FontSwitch] = []
+    codec_overrides: dict[int, Any] = {}
+
+    def flush() -> None:
+        nonlocal changed
+        if not pending:
+            return
+        _thxewrahfdqqak = ''.join((item.text for item in pending))
+        _oryzaiymhakdqi, count, _ktpnukflgendej = _apply_replacements(_thxewrahfdqqak, replacements)
+        if count:
+            try:
+                _qsjxyawyahxgsf, _uhscrkgeqkxgpq = _encode_replacement(pending[0].state.codec, _oryzaiymhakdqi, pending[0].state.font_size, fallback_resolver)
+            except FontEncodingError as _zhahwhyvmjkpmb:
+                _aloxvjwjdheyxi = str(_zhahwhyvmjkpmb)
+                if _aloxvjwjdheyxi not in report.encoding_failures:
+                    report.encoding_failures.append(_aloxvjwjdheyxi)
+                    print(f'Warning: {_aloxvjwjdheyxi}', file=sys.stderr)
+            else:
+                _set_show_text(operations, pending, _qsjxyawyahxgsf, _thxewrahfdqqak, _oryzaiymhakdqi, preserve_advance, _uhscrkgeqkxgpq, switches, codec_overrides)
+                report.replacements += count
+                matched.update(_ktpnukflgendej)
+                changed += count
+        pending.clear()
+    for index, (operands, operator) in enumerate(operations):
+        if operator == b'Tf':
+            flush()
+            if len(operands) >= 2:
+                current = codecs.get(str(operands[0]))
+                try:
+                    font_size = float(operands[1])
+                except (TypeError, ValueError):
+                    font_size = 0.0
+            continue
+        if operator == b'Tc':
+            flush()
+            character_spacing = float(operands[0]) if operands else 0.0
+            continue
+        if operator == b'Tw':
+            flush()
+            word_spacing = float(operands[0]) if operands else 0.0
+            continue
+        if operator == b'q':
+            flush()
+            graphics_stack.append((current, font_size, character_spacing, word_spacing))
+            continue
+        if operator == b'Q':
+            flush()
+            if graphics_stack:
+                current, font_size, character_spacing, word_spacing = graphics_stack.pop()
+            continue
+        if operator in TEXT_SHOW and current is not None:
+            state = TextState(current, font_size, character_spacing, word_spacing)
+            item = _show_payload(index, operator, operands, state)
+            if item is None:
+                flush()
+                continue
+            if operator not in (b'Tj', b'TJ'):
+                flush()
+                pending.append(item)
+                flush()
+            elif pending and pending[0].state != state:
+                flush()
+                pending.append(item)
+            else:
+                pending.append(item)
+            continue
+        flush()
+    flush()
+    changed += _rewrite_positioned_fragments(operations, codecs, replacements, report, matched, fallback_resolver, switches, codec_overrides)
+    _apply_font_switches(operations, switches)
+    return changed
+
+def _apply_font_switches(operations: list[tuple[list[Any], bytes]], switches: Sequence[FontSwitch]) -> None:
+    for switch in sorted(switches, key=lambda item: item.start_index, reverse=True):
+        restore = ([NameObject(switch.original_font), FloatObject(switch.font_size)], b'Tf')
+        select = ([NameObject(switch.fallback_font), FloatObject(switch.font_size)], b'Tf')
+        operations.insert(switch.end_index + 1, restore)
+        operations.insert(switch.start_index, select)
+
+def _matrix_multiply(left: list[float], right: list[float]) -> list[float]:
+    return [left[0] * right[0] + left[1] * right[2], left[0] * right[1] + left[1] * right[3], left[2] * right[0] + left[3] * right[2], left[2] * right[1] + left[3] * right[3], left[4] * right[0] + left[5] * right[2] + right[4], left[4] * right[1] + left[5] * right[3] + right[5]]
+
+def _positioned_shows(operations: list[tuple[list[Any], bytes]], codecs: Mapping[str, FontCodec], codec_overrides: Mapping[int, Any] | None=None) -> list[PositionedShow]:
+    _dvmmrmusrwxjpp: FontCodec | None = None
+    font_size = 0.0
+    character_spacing = 0.0
+    word_spacing = 0.0
+    _brcwlgpcudqsme = 0.0
+    _nukgknummdhzuh = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+    _wjlguzphrrqktg = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+    _xgejqljueoksef: list[tuple[Any, ...]] = []
+    _oqvqqtgeclndyt: list[PositionedShow] = []
+    for index, (operands, operator) in enumerate(operations):
+        if operator == b'q':
+            _xgejqljueoksef.append((_dvmmrmusrwxjpp, font_size, character_spacing, word_spacing, _brcwlgpcudqsme, _nukgknummdhzuh.copy(), _wjlguzphrrqktg.copy()))
+        elif operator == b'Q':
+            if _xgejqljueoksef:
+                _dvmmrmusrwxjpp, font_size, character_spacing, word_spacing, _brcwlgpcudqsme, _nukgknummdhzuh, _wjlguzphrrqktg = _xgejqljueoksef.pop()
+        elif operator == b'cm' and len(operands) >= 6:
+            _lpjxvpispdavam = [float(value) for value in operands[:6]]
+            _wjlguzphrrqktg = _matrix_multiply(_lpjxvpispdavam, _wjlguzphrrqktg)
+        elif operator == b'BT':
+            _nukgknummdhzuh = [1.0, 0.0, 0.0, 1.0, 0.0, 0.0]
+        elif operator == b'Tf' and len(operands) >= 2:
+            _dvmmrmusrwxjpp = codecs.get(str(operands[0]))
+            font_size = float(operands[1])
+        elif operator == b'Tc':
+            character_spacing = float(operands[0]) if operands else 0.0
+        elif operator == b'Tw':
+            word_spacing = float(operands[0]) if operands else 0.0
+        elif operator == b'TL':
+            _brcwlgpcudqsme = float(operands[0]) if operands else 0.0
+        elif operator == b'Tm' and len(operands) >= 6:
+            _nukgknummdhzuh = [float(value) for value in operands[:6]]
+        elif operator in (b'Td', b'TD') and len(operands) >= 2:
+            _oqqajzclmlhmtd, _nqqvamqfdhtesh = (float(operands[0]), float(operands[1]))
+            _nukgknummdhzuh[4] += _oqqajzclmlhmtd
+            _nukgknummdhzuh[5] += _nqqvamqfdhtesh
+            if operator == b'TD':
+                _brcwlgpcudqsme = -_nqqvamqfdhtesh
+        elif operator == b'T*':
+            _nukgknummdhzuh[5] -= _brcwlgpcudqsme
+        elif operator in TEXT_SHOW and _dvmmrmusrwxjpp is not None:
+            if operator in (b"'", b'"'):
+                _nukgknummdhzuh[5] -= _brcwlgpcudqsme
+            _jychlhollysmce = codec_overrides.get(index, _dvmmrmusrwxjpp) if codec_overrides is not None else _dvmmrmusrwxjpp
+            state = TextState(_jychlhollysmce, font_size, character_spacing, word_spacing)
+            show = _show_payload(index, operator, operands, state)
+            if show is None:
+                continue
+            x = _nukgknummdhzuh[4] * _wjlguzphrrqktg[0] + _nukgknummdhzuh[5] * _wjlguzphrrqktg[2] + _wjlguzphrrqktg[4]
+            y = _nukgknummdhzuh[4] * _wjlguzphrrqktg[1] + _nukgknummdhzuh[5] * _wjlguzphrrqktg[3] + _wjlguzphrrqktg[5]
+            _oqvqqtgeclndyt.append(PositionedShow(show, x, y))
+            _ibhhpbqhsskkym = (_jychlhollysmce.width(show.text) - show.adjustment) / 1000.0 * font_size
+            _ibhhpbqhsskkym += len(show.text) * character_spacing
+            _ibhhpbqhsskkym += show.text.count(' ') * word_spacing
+            _nukgknummdhzuh[4] += _ibhhpbqhsskkym
+    return _oqvqqtgeclndyt
+
+def _clear_show(operations: list[tuple[list[Any], bytes]], positioned: PositionedShow) -> None:
+    show = positioned.show
+    _dfjqytvrjjlioo = ByteStringObject(b'')
+    if show.operator in (b'Tj', b'TJ'):
+        operations[show.index] = ([ArrayObject([_dfjqytvrjjlioo])], b'TJ')
+    elif show.operator == b"'":
+        show.operands[0] = _dfjqytvrjjlioo
+    elif show.operator == b'"':
+        show.operands[2] = _dfjqytvrjjlioo
+
+def _set_anchored_show(operations: list[tuple[list[Any], bytes]], positioned: PositionedShow, encoded: bytes, replacement_codec: Any, switches: list[FontSwitch], codec_overrides: dict[int, Any]) -> None:
+    show = positioned.show
+    _dsnfeciqyilosk = ByteStringObject(encoded)
+    if show.operator in (b'Tj', b'TJ'):
+        operations[show.index] = ([ArrayObject([_dsnfeciqyilosk])], b'TJ')
+    elif show.operator == b"'":
+        show.operands[0] = _dsnfeciqyilosk
+    elif show.operator == b'"':
+        show.operands[2] = _dsnfeciqyilosk
+    if replacement_codec is not show.state.codec:
+        switches.append(FontSwitch(start_index=show.index, end_index=show.index, original_font=show.state.codec.resource_name, fallback_font=replacement_codec.resource_name, font_size=show.state.font_size))
+        codec_overrides[show.index] = replacement_codec
+
+def _reflow_relative_text_moves(operations: list[tuple[list[Any], bytes]], first_show_index: int, last_show_index: int, replacement_advance: float) -> None:
+    _wjefgccagqzskr: list[int] = []
+    for index in range(first_show_index + 1, last_show_index):
+        operands, operator = operations[index]
+        if operator in (b'Td', b'TD') and len(operands) >= 2 and (abs(float(operands[1])) < 1e-06):
+            _wjefgccagqzskr.append(index)
+    if not _wjefgccagqzskr:
+        return
+    for index in _wjefgccagqzskr:
+        operations[index][0][0] = FloatObject(0.0)
+    for index in range(last_show_index + 1, len(operations)):
+        operands, operator = operations[index]
+        if operator in TEXT_SHOW or operator in (b'ET', b'BT', b'Tm', b'T*'):
+            break
+        if operator in (b'Td', b'TD') and len(operands) >= 2 and (abs(float(operands[1])) < 1e-06):
+            operands[0] = FloatObject(round(replacement_advance, 6))
+            break
+
+def _rewrite_positioned_fragments(operations: list[tuple[list[Any], bytes]], codecs: Mapping[str, FontCodec], replacements: Sequence[Replacement], report: ReplacementReport, matched: set[str], fallback_resolver: FallbackResolver | None, switches: list[FontSwitch], codec_overrides: dict[int, Any]) -> int:
+    positioned = [item for item in _positioned_shows(operations, codecs, codec_overrides) if item.show.text]
+    lines: list[list[PositionedShow]] = []
+    for item in positioned:
+        tolerance = max(0.5, abs(item.show.state.font_size) * 0.2)
+        for line in lines:
+            anchor = line[0]
+            if anchor.show.state.codec is item.show.state.codec and abs(anchor.y - item.y) <= tolerance:
+                line.append(item)
+                break
+        else:
+            lines.append([item])
+    line_chains: list[list[PositionedShow]] = []
+    for line in lines:
+        line.sort(key=lambda item: item.x)
+        chains: list[list[PositionedShow]] = []
+        for item in line:
+            if not chains:
+                chains.append([item])
+                continue
+            previous = chains[-1][-1]
+            codec = item.show.state.codec
+            size = abs(item.show.state.font_size) or 1.0
+            previous_end = previous.x + codec.width(previous.show.text) / 1000.0 * size
+            space = max(codec.width(' ') / 1000.0 * size, size * 0.2)
+            gap = item.x - previous_end
+            if -space <= gap <= 2.25 * space:
+                chains[-1].append(item)
+            else:
+                chains.append([item])
+        line_chains.extend(chains)
+    changed = _replace_fragment_chains(operations, line_chains, replacements, report, matched, fallback_resolver, switches, codec_overrides)
+    refreshed = [item for item in _positioned_shows(operations, codecs, codec_overrides) if item.show.text]
+    sequential: list[list[PositionedShow]] = []
+    for item in refreshed:
+        if not sequential:
+            sequential.append([item])
+            continue
+        previous = sequential[-1][-1]
+        size = max(abs(item.show.state.font_size), 1.0)
+        nearby = abs(item.y - previous.y) <= 1.5 * size
+        close_in_stream = item.show.index - previous.show.index <= 18
+        if previous.show.state.codec is item.show.state.codec and nearby and close_in_stream:
+            sequential[-1].append(item)
+        else:
+            sequential.append([item])
+    changed += _replace_fragment_chains(operations, sequential, replacements, report, matched, fallback_resolver, switches, codec_overrides, use_content_order=True)
+    return changed
+
+def _replace_fragment_chains(operations: list[tuple[list[Any], bytes]], chains: Sequence[Sequence[PositionedShow]], replacements: Sequence[Replacement], report: ReplacementReport, matched: set[str], fallback_resolver: FallbackResolver | None, switches: list[FontSwitch], codec_overrides: dict[int, Any], *, use_content_order: bool=False) -> int:
+    _ipuzkbubtxohlx = 0
+    for _xgltulrsgubkby in chains:
+        if len(_xgltulrsgubkby) < 2:
+            continue
+        _vhwdgqlspbzbye: list[str] = []
+        _bmbvmgzgbuhybe: list[tuple[int, int] | None] = []
+        for _sobnyqibpybvpw, _lqftcyyrwbzrco in enumerate(_xgltulrsgubkby):
+            if _sobnyqibpybvpw:
+                _qkslmjfcsszwso = _xgltulrsgubkby[_sobnyqibpybvpw - 1]
+                codec = _lqftcyyrwbzrco.show.state.codec
+                _sxorndgwjbhpyi = abs(_lqftcyyrwbzrco.show.state.font_size) or 1.0
+                _vbksykdgyoovnx = _qkslmjfcsszwso.x + codec.width(_qkslmjfcsszwso.show.text) / 1000.0 * _sxorndgwjbhpyi
+                _pstrlmimrvczvn = max(codec.width(' ') / 1000.0 * _sxorndgwjbhpyi, _sxorndgwjbhpyi * 0.2)
+                _xerzilnauysewq = abs(_lqftcyyrwbzrco.y - _qkslmjfcsszwso.y) > _sxorndgwjbhpyi * 0.2
+                _onhqjureaaymkt = _lqftcyyrwbzrco.x - _vbksykdgyoovnx > 0.15 * _pstrlmimrvczvn
+                if not _qkslmjfcsszwso.show.text.endswith((' ', '\t', '\r', '\n')) and (not _lqftcyyrwbzrco.show.text.startswith((' ', '\t', '\r', '\n'))) and (_xerzilnauysewq if use_content_order else _onhqjureaaymkt):
+                    _vhwdgqlspbzbye.append(' ')
+                    _bmbvmgzgbuhybe.append(None)
+            for _vstqsyvurnrbzq, _jivjejahdqniew in enumerate(_lqftcyyrwbzrco.show.text):
+                _vhwdgqlspbzbye.append(_jivjejahdqniew)
+                _bmbvmgzgbuhybe.append((_sobnyqibpybvpw, _vstqsyvurnrbzq))
+        _jargclyilokrdx = ''.join(_vhwdgqlspbzbye)
+        _kzvwyiknixihah: list[tuple[int, int, Replacement]] = []
+        _kzdvvmtbseqatx: set[int] = set()
+        for _kkdvmnwmoodeok in replacements:
+            start = 0
+            while True:
+                _tbcratdkwytvbd = _jargclyilokrdx.find(_kkdvmnwmoodeok.old, start)
+                if _tbcratdkwytvbd < 0:
+                    break
+                _pqqcvfknomsycc = _tbcratdkwytvbd + len(_kkdvmnwmoodeok.old)
+                _mevatselfkzobf = {origin[0] for origin in _bmbvmgzgbuhybe[_tbcratdkwytvbd:_pqqcvfknomsycc] if origin is not None}
+                if len(_mevatselfkzobf) >= 2 and (not any((i in _kzdvvmtbseqatx for i in range(_tbcratdkwytvbd, _pqqcvfknomsycc)))):
+                    _kzvwyiknixihah.append((_tbcratdkwytvbd, _pqqcvfknomsycc, _kkdvmnwmoodeok))
+                    _kzdvvmtbseqatx.update(range(_tbcratdkwytvbd, _pqqcvfknomsycc))
+                start = max(_pqqcvfknomsycc, _tbcratdkwytvbd + 1)
+        for start, _pqqcvfknomsycc, _kkdvmnwmoodeok in sorted(_kzvwyiknixihah, reverse=True):
+            _fverphwioeeich = [origin for origin in _bmbvmgzgbuhybe[start:_pqqcvfknomsycc] if origin is not None]
+            if not _fverphwioeeich:
+                continue
+            _guetbtadgixmwx, _gvccrdrlhesubo = _fverphwioeeich[0]
+            _nriusfjiuxxdxx, _czxijlblnyajrl = _fverphwioeeich[-1]
+            _zzegxxeiouuwci = _xgltulrsgubkby[_guetbtadgixmwx]
+            _kvyxybezejkihj = _xgltulrsgubkby[_nriusfjiuxxdxx]
+            _vmcrznhtrtoquw = _zzegxxeiouuwci.show.text[:_gvccrdrlhesubo] + _kkdvmnwmoodeok.new + _kvyxybezejkihj.show.text[_czxijlblnyajrl + 1:]
+            try:
+                _xufnnmiraddwpb, _tzugszpyhhqdeq = _encode_replacement(_zzegxxeiouuwci.show.state.codec, _vmcrznhtrtoquw, _zzegxxeiouuwci.show.state.font_size, fallback_resolver)
+            except FontEncodingError as _kdwzjcxqeaqhjg:
+                _hnkcanibxexsqp = str(_kdwzjcxqeaqhjg)
+                if _hnkcanibxexsqp not in report.encoding_failures:
+                    report.encoding_failures.append(_hnkcanibxexsqp)
+                    print(f'Warning: {_hnkcanibxexsqp}', file=sys.stderr)
+                continue
+            _set_anchored_show(operations, _zzegxxeiouuwci, _xufnnmiraddwpb, _tzugszpyhhqdeq, switches, codec_overrides)
+            if _guetbtadgixmwx < _nriusfjiuxxdxx:
+                _reflow_relative_text_moves(operations, _zzegxxeiouuwci.show.index, _kvyxybezejkihj.show.index, _tzugszpyhhqdeq.width(_vmcrznhtrtoquw) / 1000.0 * _zzegxxeiouuwci.show.state.font_size)
+            for _wkksyolnhajvhs in _xgltulrsgubkby[_guetbtadgixmwx + 1:_nriusfjiuxxdxx + 1]:
+                _clear_show(operations, _wkksyolnhajvhs)
+            report.replacements += 1
+            matched.add(_kkdvmnwmoodeok.old)
+            _ipuzkbubtxohlx += 1
+    return _ipuzkbubtxohlx

apdf/utils.py

@@ -0,0 +1,51 @@
+from __future__ import annotations
+import os
+import sys
+from typing import Any
+from pypdf.generic import ByteStringObject, TextStringObject
+_RESET = '\x1b[0m'
+_BOLD = '\x1b[1m'
+_DIM = '\x1b[2m'
+_ITALIC = '\x1b[3m'
+_WHITE = '\x1b[97m'
+_CYAN = '\x1b[96m'
+_BLUE = '\x1b[94m'
+_GREEN = '\x1b[92m'
+_YELLOW = '\x1b[93m'
+_RED = '\x1b[91m'
+_MAGENTA = '\x1b[95m'
+_GRAY = '\x1b[90m'
+
+def _supports_color() -> bool:
+    return sys.stderr.isatty() and 'NO_COLOR' not in os.environ
+
+def _c(text: str, *styles: str) -> str:
+    if not _supports_color():
+        return text
+    return f"{''.join(styles)}{text}{_RESET}"
+
+def _deref(value: Any) -> Any:
+    try:
+        return value.get_object()
+    except Exception:
+        return value
+
+def _object_key(value: Any) -> tuple[str, int, int] | tuple[str, int]:
+    ref = getattr(value, 'indirect_reference', None)
+    if ref is not None:
+        return ('ref', int(ref.idnum), int(ref.generation))
+    return ('direct', id(value))
+
+def _raw_bytes(value: Any) -> bytes:
+    if isinstance(value, ByteStringObject):
+        return bytes(value)
+    if isinstance(value, TextStringObject):
+        return value.original_bytes
+    if isinstance(value, bytes):
+        return value
+    if isinstance(value, str):
+        return value.encode('latin-1', errors='surrogatepass')
+    raise TypeError(f'Not a PDF string operand: {type(value).__name__}')
+
+def _is_pdf_string(value: Any) -> bool:
+    return isinstance(value, (str, bytes, TextStringObject, ByteStringObject))

apdf-1.0.dist-info/METADATA

@@ -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.dist-info/RECORD

@@ -0,0 +1,14 @@
+apdf/__init__.py,sha256=D8C3qEhghuNGqbTlp-eK_FR4fTfX-NWteDBk4X2JrIE,364
+apdf/__main__.py,sha256=SzcAN5jLCfR7FbezjiJ9A21X-9LB2iiL5Ym2ds3b-tE,51
+apdf/cli.py,sha256=Gq0GQ4gK4nX98BPJuwFdGrKrdWU2lORMds06DRKnfvk,4885
+apdf/codec.py,sha256=2w5-ESvCZCFiMTsrKiiabaXxut4BzR-giFe6UxjAI-o,8415
+apdf/engine.py,sha256=RcnY3SFyBV7ydVpCQ5x1nRX6Jr-z_D2wrf0RHAkFd2E,7628
+apdf/exceptions.py,sha256=WkhmBFqleKBlETTQCUSPO7gqDF4bwptm7dm1htBG9Zc,390
+apdf/fallback.py,sha256=OXyfHMk1zvJt92a5Ryo9jffGtIC83idcjvHi_sS3z-c,12740
+apdf/models.py,sha256=i-Za3r5X8kiXcIxvI0r4I_tp6_1fkCi_ZczUQHlUH_s,1063
+apdf/operations.py,sha256=Xg7U9geHb7M4QyoenSsDPHTvEIfHpYfz_9BvaMtSawo,21964
+apdf/utils.py,sha256=7iohE2i4aImyht1RmnLfAoVsG8dVTPoS_CsKW2CqXo8,1496
+apdf-1.0.dist-info/METADATA,sha256=hfSjkcCnKMt0_Fdaon__hZeK-5xwPgS3sFMBbKGKwRA,3100
+apdf-1.0.dist-info/WHEEL,sha256=zOwg4jB6zX2kU910N-cMawjivD6tO8NEWvE12je1bVk,87
+apdf-1.0.dist-info/entry_points.txt,sha256=P_30JbdytaW1iXrO3bCidw01coWmfnvqss5zmixGcaM,44
+apdf-1.0.dist-info/RECORD,,

apdf-1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.32.0
+Root-Is-Purelib: true
+Tag: py3-none-any

apdf-1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+apdf = apdf.__main__:main