apdf 1.2__tar.gz → 1.3__tar.gz

{apdf-1.2 → apdf-1.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apdf
-Version: 1.2
+Version: 1.3
 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
@@ -61,7 +61,7 @@ rep = replace_pdf_text_detailed(
     },
 
     # Optional parameters:
-    pages={2, 3, 4},       # Only these pages
+    #pages={2, 3, 4},       # Only these pages
     # pages=2,             # Only page 2
     # pages=range(1, 6),   # Pages 1 through 5
     # pages=None,          # All pages (default)
@@ -81,7 +81,7 @@ print("Encoding failures:", rep.encoding_failures)
 ## Usage As CLI Tool
 
 ```bash
-apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] input [output]
+apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] [-p PAGELIST] input [output]
 ```
 
 ### Examples

{apdf-1.2 → apdf-1.3}/README.md

@@ -41,7 +41,7 @@ rep = replace_pdf_text_detailed(
     },
 
     # Optional parameters:
-    pages={2, 3, 4},       # Only these pages
+    #pages={2, 3, 4},       # Only these pages
     # pages=2,             # Only page 2
     # pages=range(1, 6),   # Pages 1 through 5
     # pages=None,          # All pages (default)
@@ -61,7 +61,7 @@ print("Encoding failures:", rep.encoding_failures)
 ## Usage As CLI Tool
 
 ```bash
-apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] input [output]
+apdf [-h] [-r OLD=NEW] [-nopa] [-s] [-ff FONT.ttf] [-no-ff] [-p PAGELIST] input [output]
 ```
 
 ### Examples

apdf-1.3/apdf/cli.py

@@ -0,0 +1,102 @@
+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:
+    _yexglwvsffnawf = _installed_version()
+    if _supports_color():
+        _elnqbhxbtmzjqr = _BANNER.strip('\n').splitlines()
+        _ytnyzrzieholjd = [_RED, _RED, _BLUE, _BLUE, _CYAN]
+        for _yaekunimrrgxrg, _srftlwvcvaeoen in enumerate(_elnqbhxbtmzjqr):
+            _piqkxxfcklbsrf = _ytnyzrzieholjd[_yaekunimrrgxrg] if _yaekunimrrgxrg < len(_ytnyzrzieholjd) else _CYAN
+            print(_c(_srftlwvcvaeoen, _piqkxxfcklbsrf, _BOLD), file=sys.stderr)
+    else:
+        print(_BANNER.strip('\n'), file=sys.stderr)
+    _uylanzrxtqrxso = _c(' ' + ' Low-level PDF T' + 'ext Repl' + 'acer', _DIM)
+    _ebgbjsqtetgxjd = _c(f' v{_yexglwvsffnawf} ', _BOLD, _MAGENTA)
+    _odmebanoixtncs = _c(' b' + 'y' + ' ' + 'Abodx9', _YELLOW, _BOLD)
+    print(f'{_uylanzrxtqrxso}{_ebgbjsqtetgxjd}{_odmebanoixtncs}\n', file=sys.stderr)
+    print(_c('  ' + '─' * 52, _GRAY), file=sys.stderr)
+    print(file=sys.stderr)
+
+def _parse_replacements(values: Sequence[str]) -> dict[str, str]:
+    _zszcsjpxxcncoj: dict[str, str] = {}
+    for _vphsugihrzinwv in values:
+        if '=' not in _vphsugihrzinwv:
+            raise ValueError('-r requi' + 'res OLD=N' + 'EW')
+        old, new = _vphsugihrzinwv.split('=', 1)
+        if not old:
+            raise ValueError('O' + 'LD' + ' cannot be empt' + 'y')
+        _zszcsjpxxcncoj[old] = new
+    return _zszcsjpxxcncoj
+
+def _parse_pages(value: str | None) -> set[int] | None:
+    if value is None:
+        return None
+    pages: set[int] = set()
+    for _bdlvvsabzejmct in value.split(','):
+        _jwnjjyfnbpszvo = _bdlvvsabzejmct.strip()
+        if not _jwnjjyfnbpszvo:
+            raise ValueError('-p contains' + ' an ' + 'empty page' + ' number')
+        if '-' in _jwnjjyfnbpszvo:
+            _olqxnewpzkktlx = [piece.strip() for piece in _jwnjjyfnbpszvo.split('-')]
+            if len(_olqxnewpzkktlx) != 2 or not all((piece.isdigit() for piece in _olqxnewpzkktlx)):
+                raise ValueError(f'invalid page range: {_jwnjjyfnbpszvo!r}')
+            start, _tkoxvyynftxxla = map(int, _olqxnewpzkktlx)
+            if start < 1 or _tkoxvyynftxxla < 1:
+                raise ValueError('page num' + 'bers mus' + 't be 1 or' + ' greater')
+            if start > _tkoxvyynftxxla:
+                raise ValueError(f'page range must be ascending: {_jwnjjyfnbpszvo!r}')
+            pages.update(range(start, _tkoxvyynftxxla + 1))
+        else:
+            if not _jwnjjyfnbpszvo.isdigit():
+                raise ValueError(f'invalid page number: {_jwnjjyfnbpszvo!r}')
+            _jeymhbseuolonm = int(_jwnjjyfnbpszvo)
+            if _jeymhbseuolonm < 1:
+                raise ValueError('page nu' + 'mbe' + 'rs must be 1 or greate' + 'r')
+            pages.add(_jeymhbseuolonm)
+    return pages
+
+def main(argv: Sequence[str] | None=None) -> int:
+    _print_banner()
+    if argv is None:
+        argv = sys.argv[1:]
+    _beqkwgnnaawbyl = argparse.ArgumentParser(description='Replace Unicode and Hex text dire' + 'ctly in PDF cont' + 'ent' + ' streams.')
+    _beqkwgnnaawbyl.add_argument('input', help='Inp' + 'ut' + ' PDF')
+    _beqkwgnnaawbyl.add_argument('output', nargs='?', default='output.pdf', help='Output ' + 'PDF')
+    _beqkwgnnaawbyl.add_argument('-r', action='append', default=[], metavar='OLD=NEW', dest='replace', help='Replace: Unicode replacement; may be supplied more than on' + 'ce')
+    _beqkwgnnaawbyl.add_argument('-p', metavar='PAGES', dest='pages', help='Page' + 's to edit, e.g. 2,' + ' 2,3,4, or 1-5; defaults to all pages')
+    _beqkwgnnaawbyl.add_argument('-nopa', action='store_true', dest='no_preserve_advance', help='No pres' + 'erve advance: Do not compensate TJ widt' + 'hs after replacements')
+    _beqkwgnnaawbyl.add_argument('-s', action='store_true', dest='strict', help='Strict: Fail if text is ' + 'missing or' + ' the selected font cannot encode' + ' it')
+    _beqkwgnnaawbyl.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 com" + 'mon system sans-serif font')
+    _beqkwgnnaawbyl.add_argument('-no-ff', action='store_true', dest='no_font_fallback', help='No font fallback: Reject mis' + 'sing glyphs instead of embe' + 'ddi' + 'ng a fallback font')
+    _wxgrxwtxatoxen = _beqkwgnnaawbyl.parse_args(argv)
+    try:
+        replacements = _parse_replacements(_wxgrxwtxatoxen.replace)
+        pages = _parse_pages(_wxgrxwtxatoxen.pages)
+        if not replacements:
+            _beqkwgnnaawbyl.error('pro' + 'vide at le' + 'ast' + ' one -r OLD=NEW')
+        _xlyrhnjfdmkefx = replace_pdf_text_detailed(_wxgrxwtxatoxen.input, _wxgrxwtxatoxen.output, replacements, preserve_advance=not _wxgrxwtxatoxen.no_preserve_advance, strict=_wxgrxwtxatoxen.strict, fallback_font=_wxgrxwtxatoxen.fallback_font, font_fallback=not _wxgrxwtxatoxen.no_font_fallback, pages=pages)
+    except (OSError, PdfReplacementError, ValueError) as _uzfibstyfyttzp:
+        _beqkwgnnaawbyl.exit(2, _c(f'error: {_uzfibstyfyttzp}\n', _RED))
+    except Exception as _uzfibstyfyttzp:
+        _beqkwgnnaawbyl.exit(2, _c(f'error: An unexpected error occurred: {type(_uzfibstyfyttzp).__name__}: {_uzfibstyfyttzp}\n', _RED))
+    print(_c(f'Replaced {_xlyrhnjfdmkefx.replacements} occurrence(s) in {_xlyrhnjfdmkefx.changed_streams}/{_xlyrhnjfdmkefx.scanned_streams} stream(s) in {_xlyrhnjfdmkefx.elapsed_seconds:.3f}s.', _GREEN))
+    if _xlyrhnjfdmkefx.missing:
+        print(_c('Not ' + 'f' + 'o' + 'und: ' + ', '.join((repr(value) for value in _xlyrhnjfdmkefx.missing)), _RED))
+    if _xlyrhnjfdmkefx.encoding_failures:
+        print(_c(f'Skipped {len(_xlyrhnjfdmkefx.encoding_failures)} unencodable replacement(s).', _RED))
+    print(_c(f'Saved: {_wxgrxwtxatoxen.output}', _GREEN, _BOLD))
+    return 0

apdf-1.3/apdf/codec.py

@@ -0,0 +1,270 @@
+from __future__ import annotations
+import sys
+from io import BytesIO
+from typing import Any, Mapping
+from fontTools.agl import UV2AGL
+from fontTools.pens.boundsPen import BoundsPen
+from fontTools.ttLib import TTFont
+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._embedded_ttfont: TTFont | None = None
+        self._embedded_font_bytes: bytes | None = None
+        self._embedded_font_stream: Any | None = None
+        self._embedded_ttfont_loaded = False
+        self._embedded_glyph_order: list[str] = []
+        self._drawable_glyphs: dict[int, bool] = {}
+        self._cid_to_gid_bytes: bytes | None = None
+        self._build_inverse_maps()
+        self._load_glyph_inventory()
+
+    @property
+    def description(self) -> str:
+        _dtonbtsnepubbb = str(self.pdf_font.get('/Subtype', 'unknown'))
+        _abqsmvngjipqzp = str(self.pdf_font.get('/BaseFont', 'unknown'))
+        return f'{self.resource_name} {_dtonbtsnepubbb} {_abqsmvngjipqzp}'
+
+    def _build_inverse_maps(self) -> None:
+        for _cpszezpkxhlcgm, _rrrtuzutsrcpaf in self.font.character_map.items():
+            if isinstance(_cpszezpkxhlcgm, str) and isinstance(_rrrtuzutsrcpaf, str):
+                self._unicode_to_intermediate.setdefault(_rrrtuzutsrcpaf, _cpszezpkxhlcgm)
+        encoding = self.font.encoding
+        if isinstance(encoding, dict):
+            for _mijbpyiwaochif, _nnbahipgbrogqf in encoding.items():
+                if isinstance(_mijbpyiwaochif, int) and 0 <= _mijbpyiwaochif <= 255 and isinstance(_nnbahipgbrogqf, str):
+                    self._intermediate_to_bytes.setdefault(_nnbahipgbrogqf, bytes((_mijbpyiwaochif,)))
+
+    def _load_glyph_inventory(self) -> None:
+        encoding = _deref(self.pdf_font.get('/Encoding'))
+        if isinstance(encoding, DictionaryObject):
+            code: int | None = None
+            for item in encoding.get('/Differences', []):
+                item = _deref(item)
+                if isinstance(item, int):
+                    code = int(item)
+                elif code is not None:
+                    self._difference_glyphs[code] = str(item).lstrip('/')
+                    code += 1
+        descriptor_owner = self.pdf_font
+        if str(self.pdf_font.get('/Subtype', '')) == '/Type0':
+            descendants = _deref(self.pdf_font.get('/DescendantFonts', []))
+            if descendants:
+                descriptor_owner = _deref(descendants[0])
+                cid_to_gid = _deref(descriptor_owner.get('/CIDToGIDMap'))
+                if hasattr(cid_to_gid, 'get_data'):
+                    try:
+                        self._cid_to_gid_bytes = cid_to_gid.get_data()
+                    except Exception:
+                        self._cid_to_gid_bytes = b''
+        descriptor = _deref(descriptor_owner.get('/FontDescriptor'))
+        charset = descriptor.get('/CharSet') if descriptor else None
+        if charset:
+            self._embedded_glyphs = {name for name in str(charset).split('/') if name}
+        font_file = _deref(descriptor.get('/FontFile2')) if descriptor else None
+        if font_file is not None and hasattr(font_file, 'get_data'):
+            self._embedded_font_stream = font_file
+
+    def _ensure_embedded_ttfont(self) -> None:
+        if self._embedded_ttfont_loaded:
+            return
+        self._embedded_ttfont_loaded = True
+        if self._embedded_font_bytes is None and self._embedded_font_stream is not None:
+            try:
+                self._embedded_font_bytes = self._embedded_font_stream.get_data()
+            except Exception:
+                self._embedded_font_bytes = None
+        if self._embedded_font_bytes is None:
+            return
+        try:
+            self._embedded_ttfont = TTFont(BytesIO(self._embedded_font_bytes), lazy=False, recalcBBoxes=False, recalcTimestamp=False)
+            self._embedded_glyph_order = self._embedded_ttfont.getGlyphOrder()
+        except Exception:
+            self._embedded_ttfont = None
+            self._embedded_glyph_order = []
+
+    def _gid_for_cid(self, cid: int) -> int:
+        if self._cid_to_gid_bytes is None:
+            return cid
+        _dqxyefsqqlowdi = cid * 2
+        if _dqxyefsqqlowdi + 2 > len(self._cid_to_gid_bytes):
+            return 0
+        return int.from_bytes(self._cid_to_gid_bytes[_dqxyefsqqlowdi:_dqxyefsqqlowdi + 2], 'big')
+
+    def _glyph_is_drawable(self, gid: int) -> bool:
+        cached = self._drawable_glyphs.get(gid)
+        if cached is not None:
+            return cached
+        font = self._embedded_ttfont
+        if font is None or gid <= 0 or gid >= len(self._embedded_glyph_order):
+            self._drawable_glyphs[gid] = False
+            return False
+        name = self._embedded_glyph_order[gid]
+        if name == '.notdef':
+            self._drawable_glyphs[gid] = False
+            return False
+        drawable = False
+        try:
+            glyf = font.get('glyf')
+            if glyf is not None:
+                glyph = glyf[name]
+                drawable = bool(glyph.isComposite() or int(getattr(glyph, 'numberOfContours', 0)) > 0)
+            else:
+                glyph_set = font.getGlyphSet()
+                pen = BoundsPen(glyph_set)
+                glyph_set[name].draw(pen)
+                drawable = pen.bounds is not None
+        except Exception:
+            drawable = False
+        self._drawable_glyphs[gid] = drawable
+        return drawable
+
+    def _validate_type0_glyph_outlines(self, raw: bytes) -> None:
+        self._ensure_embedded_ttfont()
+        if self._embedded_ttfont is None:
+            return
+        encoding = self.font.encoding
+        if not isinstance(encoding, str):
+            return
+        try:
+            _rzcdzoakbxyqft = raw.decode(encoding, errors='strict')
+        except (LookupError, UnicodeError):
+            return
+        for _pozbahvroafvai in _rzcdzoakbxyqft:
+            _uxqxdjmxeovyve = self.font.character_map.get(_pozbahvroafvai, _pozbahvroafvai)
+            if _uxqxdjmxeovyve and all((character.isspace() for character in _uxqxdjmxeovyve)):
+                continue
+            _fhykuxrvpsrlom = ord(_pozbahvroafvai)
+            _txhbexxrxmbeky = self._gid_for_cid(_fhykuxrvpsrlom)
+            if not self._glyph_is_drawable(_txhbexxrxmbeky):
+                _hwpecwftjyvqmd = ' '.join((f'U+{ord(character):04X}' for character in _uxqxdjmxeovyve)) or f'CID {_fhykuxrvpsrlom}'
+                raise FontEncodingError(f'{self.description} embedded subset has no drawable glyph for {_hwpecwftjyvqmd} (CID {_fhykuxrvpsrlom}, GID {_txhbexxrxmbeky})')
+
+    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):
+            _xdjugpuibuolde = encoding.get(code)
+            if isinstance(_xdjugpuibuolde, str) and len(_xdjugpuibuolde) == 1:
+                return UV2AGL.get(ord(_xdjugpuibuolde))
+        _ipxmujfdbqmznv = str(self.pdf_font.get('/Encoding', ''))
+        codec = {'/WinAnsiEncoding': 'cp1252', '/MacRomanEncoding': 'mac_roman'}.get(_ipxmujfdbqmznv, 'latin-1')
+        try:
+            _yhbgyxeyqreqah = bytes((code,)).decode(codec)
+        except (UnicodeDecodeError, LookupError):
+            return None
+        return UV2AGL.get(ord(_yhbgyxeyqreqah))
+
+    def _validate_embedded_glyphs(self, raw: bytes, visible: str) -> None:
+        _aojpgqqhfkrpwi = str(self.pdf_font.get('/Subtype', ''))
+        if _aojpgqqhfkrpwi == '/Type3':
+            encoding = self.font.encoding
+            if isinstance(encoding, dict):
+                for _gcjnhinzjlcpmh in raw:
+                    _mnkuifxpsuezme = encoding.get(_gcjnhinzjlcpmh, chr(_gcjnhinzjlcpmh))
+                    if _mnkuifxpsuezme not in self.font.character_map:
+                        raise FontEncodingError(f'{self.description} has no explicit Type3 mapping for character code 0x{_gcjnhinzjlcpmh:02X}')
+            if self.decode(raw) != visible:
+                raise FontEncodingError(f'{self.description} has no reversible glyph mapping for {visible!r}')
+            return
+        if _aojpgqqhfkrpwi == '/Type0':
+            self._validate_type0_glyph_outlines(raw)
+        if self._embedded_glyphs is not None:
+            missing: list[str] = []
+            for _gcjnhinzjlcpmh in raw:
+                _vsecktyjcjrjfy = self._glyph_name_for_code(_gcjnhinzjlcpmh)
+                if _vsecktyjcjrjfy and _vsecktyjcjrjfy not in self._embedded_glyphs:
+                    missing.append(_vsecktyjcjrjfy)
+            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:
+                _prjxvllsrsceqe = raw.decode(encoding, errors='surrogatepass')
+            except (LookupError, UnicodeError):
+                _vvtbwoypfiegky = 'utf-16-be' if len(raw) % 2 == 0 else 'latin-1'
+                _prjxvllsrsceqe = raw.decode(_vvtbwoypfiegky, errors='replace')
+        else:
+            _prjxvllsrsceqe = ''.join((encoding.get(byte, chr(byte)) for byte in raw))
+        return ''.join((self.font.character_map.get(character, character) for character in _prjxvllsrsceqe))
+
+    @staticmethod
+    def _greedy_map(text: str, mapping: Mapping[str, str]) -> str:
+        if not mapping:
+            return text
+        _cfguxjxbjcwaau = sorted(mapping, key=len, reverse=True)
+        output: list[str] = []
+        _qjbwwztaspnkuz = 0
+        while _qjbwwztaspnkuz < len(text):
+            for key in _cfguxjxbjcwaau:
+                if key and text.startswith(key, _qjbwwztaspnkuz):
+                    output.append(mapping[key])
+                    _qjbwwztaspnkuz += len(key)
+                    break
+            else:
+                output.append(text[_qjbwwztaspnkuz])
+                _qjbwwztaspnkuz += 1
+        return ''.join(output)
+
+    def encode(self, visible: str) -> bytes:
+        _bwcwwxglrozrgj = self._greedy_map(visible, self._unicode_to_intermediate)
+        encoding = self.font.encoding
+        if isinstance(encoding, str):
+            try:
+                _zwmhatqlzblobv = _bwcwwxglrozrgj.encode(encoding, errors='strict')
+            except (LookupError, UnicodeError) as _dbmfrervtovraa:
+                raise FontEncodingError(f'{self.description} cannot encode {visible!r}') from _dbmfrervtovraa
+            self._validate_embedded_glyphs(_zwmhatqlzblobv, visible)
+            return _zwmhatqlzblobv
+        _habhwtgwcviujd = sorted(self._intermediate_to_bytes, key=len, reverse=True)
+        _qeoxigncjzbjdy = bytearray()
+        _plyeupfjypdihj = 0
+        while _plyeupfjypdihj < len(_bwcwwxglrozrgj):
+            for key in _habhwtgwcviujd:
+                if key and _bwcwwxglrozrgj.startswith(key, _plyeupfjypdihj):
+                    _qeoxigncjzbjdy.extend(self._intermediate_to_bytes[key])
+                    _plyeupfjypdihj += len(key)
+                    break
+            else:
+                raise FontEncodingError(f'{self.description} cannot encode character {_bwcwwxglrozrgj[_plyeupfjypdihj]!r} in {visible!r}')
+        _zwmhatqlzblobv = bytes(_qeoxigncjzbjdy)
+        self._validate_embedded_glyphs(_zwmhatqlzblobv, visible)
+        return _zwmhatqlzblobv
+
+    def width(self, visible: str) -> float:
+        try:
+            _bvfcdxkscamzsr = self._greedy_map(visible, self._unicode_to_intermediate)
+            _ctwrdofcwpavtu = self.font.character_widths
+            default = float(_ctwrdofcwpavtu.get('default', 0.0))
+            return sum((float(_ctwrdofcwpavtu.get(character, default)) for character in _bvfcdxkscamzsr))
+        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.3/apdf/engine.py

@@ -0,0 +1,210 @@
+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, DictionaryObject, NameObject, 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 _ugpcfjadzgdirg:
+        raise PdfReplacementError('Cannot r' + 'ewrite a content stream with its current' + ' PDF filters') from _ugpcfjadzgdirg
+
+def _rewrite_stream(stream: StreamObject, pdf: PdfWriter, resources: Any, replacements: Sequence[Replacement], preserve_advance: bool, report: ReplacementReport, matched: set[str], fallback_registry: FallbackFontRegistry, page_number: int) -> 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, page_number, 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]:
+    _neazdpgwrnkyhw = _deref(owner.get('/Contents'))
+    if _neazdpgwrnkyhw is None:
+        return
+    if isinstance(_neazdpgwrnkyhw, (list, ArrayObject)):
+        for _bufadhhaukiyve in _neazdpgwrnkyhw:
+            _dayimapdbmhlhp = _deref(_bufadhhaukiyve)
+            if isinstance(_dayimapdbmhlhp, StreamObject):
+                yield _dayimapdbmhlhp
+    elif isinstance(_neazdpgwrnkyhw, StreamObject):
+        yield _neazdpgwrnkyhw
+
+def _shallow_stream_clone(stream: StreamObject, writer: PdfWriter) -> Any:
+    _wfeyjveilhmvmf = type(stream)()
+    for key, _hwggqkeyajawhf in stream.items():
+        if str(key) != '/Length':
+            _wfeyjveilhmvmf[key] = _hwggqkeyajawhf
+    _wfeyjveilhmvmf._data = stream._data
+    return writer._add_object(_wfeyjveilhmvmf)
+
+def _isolate_resources(resources: Any, writer: PdfWriter, forms: dict[tuple[Any, ...], Any]) -> DictionaryObject:
+    _qvjhxwvnscjxwg = _deref(resources)
+    _goaibhlcgkcnri = DictionaryObject()
+    if not _qvjhxwvnscjxwg:
+        return _goaibhlcgkcnri
+    for key, _zfeehupelhlfhe in _qvjhxwvnscjxwg.items():
+        _goaibhlcgkcnri[key] = _zfeehupelhlfhe
+    _yrlfrkxsowknpg = _deref(_qvjhxwvnscjxwg.get('/Font'))
+    if _yrlfrkxsowknpg is not None:
+        _goaibhlcgkcnri[NameObject('/Font')] = DictionaryObject(_yrlfrkxsowknpg.items())
+    _qnfihroivpagha = _deref(_qvjhxwvnscjxwg.get('/XObject'))
+    if _qnfihroivpagha is not None:
+        _exberyaazfdcst = DictionaryObject()
+        _goaibhlcgkcnri[NameObject('/XObject')] = _exberyaazfdcst
+        for name, _txolusbadwgrya in _qnfihroivpagha.items():
+            _ppdzawokdondzc = _deref(_txolusbadwgrya)
+            if not isinstance(_ppdzawokdondzc, StreamObject) or _ppdzawokdondzc.get('/Subtype') != '/Form':
+                _exberyaazfdcst[name] = _txolusbadwgrya
+                continue
+            key = _object_key(_ppdzawokdondzc)
+            _satjsphwxjxnya = forms.get(key)
+            if _satjsphwxjxnya is None:
+                _satjsphwxjxnya = _shallow_stream_clone(_ppdzawokdondzc, writer)
+                forms[key] = _satjsphwxjxnya
+                _ualqasmuyrlrqd = _deref(_satjsphwxjxnya)
+                _vhiyefugqdsdwl = _ppdzawokdondzc.get('/Resources')
+                if _vhiyefugqdsdwl is not None:
+                    _ualqasmuyrlrqd[NameObject('/Resources')] = _isolate_resources(_vhiyefugqdsdwl, writer, forms)
+            _exberyaazfdcst[name] = _satjsphwxjxnya
+    return _goaibhlcgkcnri
+
+def _isolate_contents(contents: Any, writer: PdfWriter) -> Any:
+    _fkbsewzneyskya = _deref(contents)
+    if isinstance(_fkbsewzneyskya, (list, ArrayObject)):
+        _rujmummusiizgx = ArrayObject()
+        for _fknsoginotgtdd in _fkbsewzneyskya:
+            _ryfrzizgkphqcw = _deref(_fknsoginotgtdd)
+            _rujmummusiizgx.append(_shallow_stream_clone(_ryfrzizgkphqcw, writer) if isinstance(_ryfrzizgkphqcw, StreamObject) else _fknsoginotgtdd)
+        return _rujmummusiizgx
+    if isinstance(_fkbsewzneyskya, StreamObject):
+        return _shallow_stream_clone(_fkbsewzneyskya, writer)
+    return contents
+
+def _isolate_selected_page(page: Any, writer: PdfWriter) -> None:
+    _xfosugyumsurgg = page.get('/Contents')
+    if _xfosugyumsurgg is not None:
+        page[NameObject('/Contents')] = _isolate_contents(_xfosugyumsurgg, writer)
+    _vkdvwpzmynlyno = page.get('/Resources')
+    if _vkdvwpzmynlyno is not None:
+        page[NameObject('/Resources')] = _isolate_resources(_vkdvwpzmynlyno, writer, {})
+
+def _selected_page_numbers(pages: Iterable[int] | int | None, page_count: int) -> set[int]:
+    if pages is None:
+        return set(range(1, page_count + 1))
+    if isinstance(pages, bool):
+        raise ValueError('pages must cont' + 'ain page numbers, not a boolean')
+    if isinstance(pages, int):
+        _obwbprdoklcsrk = {pages}
+    elif isinstance(pages, (str, bytes)):
+        raise ValueError('pages must b' + 'e page' + ' number' + 's; use the CLI -p option for ranges')
+    else:
+        _obwbprdoklcsrk = {int(page) for page in pages}
+    if not _obwbprdoklcsrk:
+        raise ValueError('at least one page must be selecte' + 'd')
+    _eaambvomkguowr = sorted((page for page in _obwbprdoklcsrk if page < 1 or page > page_count))
+    if _eaambvomkguowr:
+        _pvlavdaqfuzuzq = ', '.join((str(page) for page in _eaambvomkguowr))
+        raise ValueError(f'page selection out of range: {_pvlavdaqfuzuzq}; PDF has {page_count} page(s)')
+    return _obwbprdoklcsrk
+
+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, page_number: int) -> 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, page_number)
+        _rewrite_forms(form_resources, pdf, replacements, preserve_advance, report, matched, visited, fallback_registry, page_number)
+
+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, pages: Iterable[int] | int | None=None) -> ReplacementReport:
+    _jyhvxxfycftmnc = time.perf_counter()
+    _bvspezhylfkdnj = [Replacement(str(old), str(new)) for old, new in replacements.items() if old]
+    if not _bvspezhylfkdnj:
+        raise ValueError('At least on' + 'e non-empty sourc' + 'e string' + ' is required')
+    _ymqeotapitgtmu = Path(input_pdf)
+    _vrppczsatjqpcp = Path(output_pdf)
+    if not _ymqeotapitgtmu.is_file():
+        raise PdfFileNotFoundError(f'File not found: {_ymqeotapitgtmu}')
+    _vrppczsatjqpcp.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        _gjzrhihamjwcvu = PdfReader(_ymqeotapitgtmu, strict=False)
+    except DependencyError as _jaychfagiqcghf:
+        raise PdfDependencyError(f"Missing dependency for encrypted PDF: {_jaychfagiqcghf}\nPlease install it, e.g., 'uv pip install cryptography'") from _jaychfagiqcghf
+    except PermissionError as _jaychfagiqcghf:
+        raise PdfPermissionError(f'Permission denied when opening {_ymqeotapitgtmu}. The PDF might be opened by another application.') from _jaychfagiqcghf
+    if _gjzrhihamjwcvu.is_encrypted:
+        raise PdfReplacementError('E' + 'ncrypted P' + 'DFs are no' + 't supported without a password')
+    writer = PdfWriter(clone_from=_gjzrhihamjwcvu)
+    _vahcrawjnhoeeu = _selected_page_numbers(pages, len(writer.pages))
+    _jpdxghcahiblhs = len(_vahcrawjnhoeeu) != len(writer.pages)
+    _kpoajrmsgwgebq = FallbackFontRegistry(writer, explicit_font=fallback_font, enabled=font_fallback)
+    _kwvbmdsitcleny = ReplacementReport(pages=len(writer.pages))
+    _pgfbmwtzgqhwpu: set[str] = set()
+    _jchjazcahpawrz: set[tuple[Any, ...]] = set()
+    for _hasupdutpcshsp, _ccjftxomkyeqpp in enumerate(writer.pages, start=1):
+        if _hasupdutpcshsp not in _vahcrawjnhoeeu:
+            continue
+        print(_c(f'Processing page {_hasupdutpcshsp}/{_kwvbmdsitcleny.pages}', _BLUE), file=sys.stderr)
+        if _jpdxghcahiblhs:
+            _isolate_selected_page(_ccjftxomkyeqpp, writer)
+        _xjgejknjifwjnp = _deref(_ccjftxomkyeqpp.get('/Resources', {}))
+        for _hfzdavhzclbqdu in _content_streams(_ccjftxomkyeqpp):
+            key = _object_key(_hfzdavhzclbqdu)
+            if key in _jchjazcahpawrz:
+                continue
+            _jchjazcahpawrz.add(key)
+            _rewrite_stream(_hfzdavhzclbqdu, writer, _xjgejknjifwjnp, _bvspezhylfkdnj, preserve_advance, _kwvbmdsitcleny, _pgfbmwtzgqhwpu, _kpoajrmsgwgebq, _hasupdutpcshsp)
+        _rewrite_forms(_xjgejknjifwjnp, writer, _bvspezhylfkdnj, preserve_advance, _kwvbmdsitcleny, _pgfbmwtzgqhwpu, _jchjazcahpawrz, _kpoajrmsgwgebq, _hasupdutpcshsp)
+    _kpoajrmsgwgebq.finalize()
+    _kwvbmdsitcleny.missing = [rule.old for rule in _bvspezhylfkdnj if rule.old not in _pgfbmwtzgqhwpu]
+    _kwvbmdsitcleny.elapsed_seconds = time.perf_counter() - _jyhvxxfycftmnc
+    if strict and (_kwvbmdsitcleny.missing or _kwvbmdsitcleny.encoding_failures):
+        _nezldqejbyizsc = []
+        if _kwvbmdsitcleny.missing:
+            _nezldqejbyizsc.append(f'not found: {_kwvbmdsitcleny.missing!r}')
+        if _kwvbmdsitcleny.encoding_failures:
+            _nezldqejbyizsc.append(f'encoding failures: {_kwvbmdsitcleny.encoding_failures!r}')
+        raise PdfReplacementError('; '.join(_nezldqejbyizsc))
+    writer.compress_identical_objects(remove_duplicates=True, remove_unreferenced=True)
+    _uskarlkklezhao: str | None = None
+    try:
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', prefix=f'.{_vrppczsatjqpcp.name}.', suffix='.tmp', dir=_vrppczsatjqpcp.parent, delete=False) as _mvbqwmzhbcjcxs:
+                _uskarlkklezhao = _mvbqwmzhbcjcxs.name
+                writer.write(_mvbqwmzhbcjcxs)
+            _haaipmhglhleal = PdfReader(_uskarlkklezhao, strict=False)
+            if len(_haaipmhglhleal.pages) != _kwvbmdsitcleny.pages:
+                raise PdfReplacementError('O' + 'utput ' + 'verification found a page-c' + 'ount mismatch')
+            os.replace(_uskarlkklezhao, _vrppczsatjqpcp)
+            _uskarlkklezhao = None
+        except PermissionError as _jaychfagiqcghf:
+            raise PdfPermissionError(f'Permission denied when saving to {_vrppczsatjqpcp}. The PDF might be opened by another application.') from _jaychfagiqcghf
+    finally:
+        if _uskarlkklezhao and os.path.exists(_uskarlkklezhao):
+            os.unlink(_uskarlkklezhao)
+    _kwvbmdsitcleny.elapsed_seconds = time.perf_counter() - _jyhvxxfycftmnc
+    return _kwvbmdsitcleny
+
+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