apdf 1.0__tar.gz → 1.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: apdf
-Version: 1.0
+Version: 1.2
 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
@@ -18,7 +18,7 @@ Requires-Dist: fonttools==4.63.0
 Requires-Dist: pypdf==6.16.1
 Description-Content-Type: text/markdown
 
-# Another PDF editor
+# A-PDF
 
 **A-PDF** is a fast, command-line tool designed to replace Unicode and Hex text directly within PDF content streams. 
 
@@ -28,6 +28,7 @@ Description-Content-Type: text/markdown
 - **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.
+- **Page Selection**: Select specific pages to process.
 
 ## Installation
 
@@ -45,7 +46,39 @@ pip install apdf
 apdf --help
 ```
 
-## Usage
+## Usage As Library
+
+```python
+from apdf import replace_pdf_text_detailed
+
+rep = replace_pdf_text_detailed(
+    input_pdf="Test1.pdf",
+    output_pdf="Test1_out.pdf",
+    replacements={
+        "Old Text": "New Text",
+        # "Hello": "World",
+        # "2026": "2027", 
+    },
+
+    # Optional parameters:
+    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)
+
+    # fallback_font="FONT.ttf",
+    # font_fallback=True,
+    # strict=True,
+)
+
+print("Replacements:", rep.replacements)
+print("Changed streams:", rep.changed_streams)
+print("Scanned streams:", rep.scanned_streams)
+print("Missing:", rep.missing)
+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]
@@ -80,6 +113,8 @@ apdf input.pdf output.pdf -r "foo=bar" -s
 * `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.
+* `-p 2`, `-p 2,3,4`, or `-p 1-5` to edit only selected pages. Without
+  `-p`, all pages are processed.
 * `-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.

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

@@ -1,4 +1,4 @@
-# Another PDF editor
+# A-PDF
 
 **A-PDF** is a fast, command-line tool designed to replace Unicode and Hex text directly within PDF content streams. 
 
@@ -8,6 +8,7 @@
 - **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.
+- **Page Selection**: Select specific pages to process.
 
 ## Installation
 
@@ -25,7 +26,39 @@ pip install apdf
 apdf --help
 ```
 
-## Usage
+## Usage As Library
+
+```python
+from apdf import replace_pdf_text_detailed
+
+rep = replace_pdf_text_detailed(
+    input_pdf="Test1.pdf",
+    output_pdf="Test1_out.pdf",
+    replacements={
+        "Old Text": "New Text",
+        # "Hello": "World",
+        # "2026": "2027", 
+    },
+
+    # Optional parameters:
+    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)
+
+    # fallback_font="FONT.ttf",
+    # font_fallback=True,
+    # strict=True,
+)
+
+print("Replacements:", rep.replacements)
+print("Changed streams:", rep.changed_streams)
+print("Scanned streams:", rep.scanned_streams)
+print("Missing:", rep.missing)
+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]
@@ -60,6 +93,8 @@ apdf input.pdf output.pdf -r "foo=bar" -s
 * `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.
+* `-p 2`, `-p 2,3,4`, or `-p 1-5` to edit only selected pages. Without
+  `-p`, all pages are processed.
 * `-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.

apdf-1.2/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:
+    _amswkxtziscddt = _installed_version()
+    if _supports_color():
+        _dbeoudxilennje = _BANNER.strip('\n').splitlines()
+        _dtfuvktjmwgvjl = [_RED, _RED, _BLUE, _BLUE, _CYAN]
+        for _wqkqcfhqfcawmm, _svuhqohydsiiyg in enumerate(_dbeoudxilennje):
+            _gbgexydwonsspj = _dtfuvktjmwgvjl[_wqkqcfhqfcawmm] if _wqkqcfhqfcawmm < len(_dtfuvktjmwgvjl) else _CYAN
+            print(_c(_svuhqohydsiiyg, _gbgexydwonsspj, _BOLD), file=sys.stderr)
+    else:
+        print(_BANNER.strip('\n'), file=sys.stderr)
+    _jtwtfqmxwneoft = _c('  Low-level PDF Te' + 'xt Replacer', _DIM)
+    _sgfacrlkmprjnb = _c(f' v{_amswkxtziscddt} ', _BOLD, _MAGENTA)
+    _cdaqjslqrxukic = _c(' by Abodx' + '9', _YELLOW, _BOLD)
+    print(f'{_jtwtfqmxwneoft}{_sgfacrlkmprjnb}{_cdaqjslqrxukic}\n', file=sys.stderr)
+    print(_c('  ' + '─' * 52, _GRAY), file=sys.stderr)
+    print(file=sys.stderr)
+
+def _parse_replacements(values: Sequence[str]) -> dict[str, str]:
+    _qfrpzdwqfdzlmi: dict[str, str] = {}
+    for _dxupsndrhayzgq in values:
+        if '=' not in _dxupsndrhayzgq:
+            raise ValueError('-r requires OLD=NE' + 'W')
+        old, new = _dxupsndrhayzgq.split('=', 1)
+        if not old:
+            raise ValueError('OLD cannot b' + 'e empty')
+        _qfrpzdwqfdzlmi[old] = new
+    return _qfrpzdwqfdzlmi
+
+def _parse_pages(value: str | None) -> set[int] | None:
+    if value is None:
+        return None
+    pages: set[int] = set()
+    for _olmmerqreqttbs in value.split(','):
+        _hpcjkwacufzsbb = _olmmerqreqttbs.strip()
+        if not _hpcjkwacufzsbb:
+            raise ValueError('-p contains an empty p' + 'age number')
+        if '-' in _hpcjkwacufzsbb:
+            _nyefzumqaqiojc = [piece.strip() for piece in _hpcjkwacufzsbb.split('-')]
+            if len(_nyefzumqaqiojc) != 2 or not all((piece.isdigit() for piece in _nyefzumqaqiojc)):
+                raise ValueError(f'invalid page range: {_hpcjkwacufzsbb!r}')
+            start, _wnpdxkishjpszz = map(int, _nyefzumqaqiojc)
+            if start < 1 or _wnpdxkishjpszz < 1:
+                raise ValueError('page numbers ' + 'must be 1 or greater')
+            if start > _wnpdxkishjpszz:
+                raise ValueError(f'page range must be ascending: {_hpcjkwacufzsbb!r}')
+            pages.update(range(start, _wnpdxkishjpszz + 1))
+        else:
+            if not _hpcjkwacufzsbb.isdigit():
+                raise ValueError(f'invalid page number: {_hpcjkwacufzsbb!r}')
+            _pblbvcmmbkfown = int(_hpcjkwacufzsbb)
+            if _pblbvcmmbkfown < 1:
+                raise ValueError('page numbers must be 1 or greate' + 'r')
+            pages.add(_pblbvcmmbkfown)
+    return pages
+
+def main(argv: Sequence[str] | None=None) -> int:
+    _print_banner()
+    if argv is None:
+        argv = sys.argv[1:]
+    _xfsdndyzqtewaa = argparse.ArgumentParser(description='Replace Unico' + 'de and ' + 'Hex text directly in PDF content streams.')
+    _xfsdndyzqtewaa.add_argument('input', help='In' + 'pu' + 't' + ' PDF')
+    _xfsdndyzqtewaa.add_argument('output', nargs='?', default='output.pdf', help='Outp' + 'ut PDF')
+    _xfsdndyzqtewaa.add_argument('-r', action='append', default=[], metavar='OLD=NEW', dest='replace', help='Replace: Unicode' + ' replacement; may be supplied' + ' ' + 'more than once')
+    _xfsdndyzqtewaa.add_argument('-p', metavar='PAGES', dest='pages', help='Pages to edit, e.g. 2, 2,3,4, or 1-5; defaults to' + ' all pages')
+    _xfsdndyzqtewaa.add_argument('-nopa', action='store_true', dest='no_preserve_advance', help='No preserve a' + 'dvanc' + 'e: Do not compensate TJ widths after replacements')
+    _xfsdndyzqtewaa.add_argument('-s', action='store_true', dest='strict', help='Strict: Fail if text is missing' + ' or the selected font cannot encode ' + 'it')
+    _xfsdndyzqtewaa.add_argument('-ff', metavar='FONT.ttf', dest='fallback_font', help='Fallback font: TrueType ' + 'font to emb' + "ed when the PDF's subset font lacks a glyph; defaults to a common system sans" + '-serif font')
+    _xfsdndyzqtewaa.add_argument('-no-ff', action='store_true', dest='no_font_fallback', help='No font fallback: Reject missing glyphs instead of embedding a fallback f' + 'ont')
+    _mwbmhuvhqcexzn = _xfsdndyzqtewaa.parse_args(argv)
+    try:
+        replacements = _parse_replacements(_mwbmhuvhqcexzn.replace)
+        pages = _parse_pages(_mwbmhuvhqcexzn.pages)
+        if not replacements:
+            _xfsdndyzqtewaa.error('provide at ' + 'l' + 'east one -r OLD=NEW')
+        _gslytzbbikuhza = replace_pdf_text_detailed(_mwbmhuvhqcexzn.input, _mwbmhuvhqcexzn.output, replacements, preserve_advance=not _mwbmhuvhqcexzn.no_preserve_advance, strict=_mwbmhuvhqcexzn.strict, fallback_font=_mwbmhuvhqcexzn.fallback_font, font_fallback=not _mwbmhuvhqcexzn.no_font_fallback, pages=pages)
+    except (OSError, PdfReplacementError, ValueError) as _hnjryszzanbgws:
+        _xfsdndyzqtewaa.exit(2, _c(f'error: {_hnjryszzanbgws}\n', _RED))
+    except Exception as _hnjryszzanbgws:
+        _xfsdndyzqtewaa.exit(2, _c(f'error: An unexpected error occurred: {type(_hnjryszzanbgws).__name__}: {_hnjryszzanbgws}\n', _RED))
+    print(_c(f'Replaced {_gslytzbbikuhza.replacements} occurrence(s) in {_gslytzbbikuhza.changed_streams}/{_gslytzbbikuhza.scanned_streams} stream(s) in {_gslytzbbikuhza.elapsed_seconds:.3f}s.', _GREEN))
+    if _gslytzbbikuhza.missing:
+        print(_c('Not fou' + 'nd: ' + ', '.join((repr(value) for value in _gslytzbbikuhza.missing)), _RED))
+    if _gslytzbbikuhza.encoding_failures:
+        print(_c(f'Skipped {len(_gslytzbbikuhza.encoding_failures)} unencodable replacement(s).', _RED))
+    print(_c(f'Saved: {_mwbmhuvhqcexzn.output}', _GREEN, _BOLD))
+    return 0

{apdf-1.0 → apdf-1.2}/apdf/codec.py

@@ -22,70 +22,70 @@ class FontCodec:
 
     @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}'
+        _uyxuhhghnfdole = str(self.pdf_font.get('/Subtype', 'unknown'))
+        _hfgtpkklfwfyhu = str(self.pdf_font.get('/BaseFont', 'unknown'))
+        return f'{self.resource_name} {_uyxuhhghnfdole} {_hfgtpkklfwfyhu}'
 
     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)
+        for _lcvsmynogancdz, _eosacjoncaonky in self.font.character_map.items():
+            if isinstance(_lcvsmynogancdz, str) and isinstance(_eosacjoncaonky, str):
+                self._unicode_to_intermediate.setdefault(_eosacjoncaonky, _lcvsmynogancdz)
         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,)))
+            for _qpgpfkcfrltxfd, _bdjwjukswkkzno in encoding.items():
+                if isinstance(_qpgpfkcfrltxfd, int) and 0 <= _qpgpfkcfrltxfd <= 255 and isinstance(_bdjwjukswkkzno, str):
+                    self._intermediate_to_bytes.setdefault(_bdjwjukswkkzno, bytes((_qpgpfkcfrltxfd,)))
 
     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}
+            _idyuovizmaukyk: int | None = None
+            for _rpkqhzmqmopedm in encoding.get('/Differences', []):
+                _rpkqhzmqmopedm = _deref(_rpkqhzmqmopedm)
+                if isinstance(_rpkqhzmqmopedm, int):
+                    _idyuovizmaukyk = int(_rpkqhzmqmopedm)
+                elif _idyuovizmaukyk is not None:
+                    self._difference_glyphs[_idyuovizmaukyk] = str(_rpkqhzmqmopedm).lstrip('/')
+                    _idyuovizmaukyk += 1
+        _wwcgqjoucuolee = _deref(self.pdf_font.get('/FontDescriptor'))
+        _fahxkzceocodwc = _wwcgqjoucuolee.get('/CharSet') if _wwcgqjoucuolee else None
+        if _fahxkzceocodwc:
+            self._embedded_glyphs = {name for name in str(_fahxkzceocodwc).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')
+            _dywvfsvhnaqyii = encoding.get(code)
+            if isinstance(_dywvfsvhnaqyii, str) and len(_dywvfsvhnaqyii) == 1:
+                return UV2AGL.get(ord(_dywvfsvhnaqyii))
+        _tchrccifvowoxq = str(self.pdf_font.get('/Encoding', ''))
+        codec = {'/WinAnsiEncoding': 'cp1252', '/MacRomanEncoding': 'mac_roman'}.get(_tchrccifvowoxq, 'latin-1')
         try:
-            _ltexlwkjjboggt = bytes((code,)).decode(codec)
+            _qaxtbdsbsyhctz = bytes((code,)).decode(codec)
         except (UnicodeDecodeError, LookupError):
             return None
-        return UV2AGL.get(ord(_ltexlwkjjboggt))
+        return UV2AGL.get(ord(_qaxtbdsbsyhctz))
 
     def _validate_embedded_glyphs(self, raw: bytes, visible: str) -> None:
-        _cmjxrgamnknxhq = str(self.pdf_font.get('/Subtype', ''))
-        if _cmjxrgamnknxhq == '/Type3':
+        _eoqbsnlnttdoyj = str(self.pdf_font.get('/Subtype', ''))
+        if _eoqbsnlnttdoyj == '/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}')
+                for _otreezbwbhttam in raw:
+                    _jwdtjvgtwfyfil = encoding.get(_otreezbwbhttam, chr(_otreezbwbhttam))
+                    if _jwdtjvgtwfyfil not in self.font.character_map:
+                        raise FontEncodingError(f'{self.description} has no explicit Type3 mapping for character code 0x{_otreezbwbhttam: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)
+            for _otreezbwbhttam in raw:
+                _thkcwazszuuere = self._glyph_name_for_code(_otreezbwbhttam)
+                if _thkcwazszuuere and _thkcwazszuuere not in self._embedded_glyphs:
+                    missing.append(_thkcwazszuuere)
             if missing:
                 names = ', '.join(sorted(set(missing)))
                 raise FontEncodingError(f'{self.description} embedded subset lacks glyph(s): {names}')
@@ -96,56 +96,56 @@ class FontCodec:
         encoding = self.font.encoding
         if isinstance(encoding, str):
             try:
-                _dwjqepqdmzpydx = raw.decode(encoding, errors='surrogatepass')
+                _xplgkxapbgdsjn = 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')
+                _yszhhuogijrnto = 'utf-16-be' if len(raw) % 2 == 0 else 'latin-1'
+                _xplgkxapbgdsjn = raw.decode(_yszhhuogijrnto, 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))
+            _xplgkxapbgdsjn = ''.join((encoding.get(byte, chr(byte)) for byte in raw))
+        return ''.join((self.font.character_map.get(character, character) for character in _xplgkxapbgdsjn))
 
     @staticmethod
     def _greedy_map(text: str, mapping: Mapping[str, str]) -> str:
         if not mapping:
             return text
-        _taysbvduzlwvpf = sorted(mapping, key=len, reverse=True)
+        _dmfudfobrlgihq = 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):
+        _cckiwwydtundcz = 0
+        while _cckiwwydtundcz < len(text):
+            for key in _dmfudfobrlgihq:
+                if key and text.startswith(key, _cckiwwydtundcz):
                     output.append(mapping[key])
-                    _rjciwatenvnubt += len(key)
+                    _cckiwwydtundcz += len(key)
                     break
             else:
-                output.append(text[_rjciwatenvnubt])
-                _rjciwatenvnubt += 1
+                output.append(text[_cckiwwydtundcz])
+                _cckiwwydtundcz += 1
         return ''.join(output)
 
     def encode(self, visible: str) -> bytes:
-        _mqcsiaerslqqcw = self._greedy_map(visible, self._unicode_to_intermediate)
+        _exvunfwfpazrqi = 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)
+                _okuzpqmtslbyny = _exvunfwfpazrqi.encode(encoding, errors='strict')
+            except (LookupError, UnicodeError) as _ummwdfctjvzuyw:
+                raise FontEncodingError(f'{self.description} cannot encode {visible!r}') from _ummwdfctjvzuyw
+            self._validate_embedded_glyphs(_okuzpqmtslbyny, visible)
+            return _okuzpqmtslbyny
+        _qcjmtvbxylehwm = sorted(self._intermediate_to_bytes, key=len, reverse=True)
+        _dsncebznuwabyp = bytearray()
+        _rjokoymizxbigc = 0
+        while _rjokoymizxbigc < len(_exvunfwfpazrqi):
+            for key in _qcjmtvbxylehwm:
+                if key and _exvunfwfpazrqi.startswith(key, _rjokoymizxbigc):
+                    _dsncebznuwabyp.extend(self._intermediate_to_bytes[key])
+                    _rjokoymizxbigc += 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
+                raise FontEncodingError(f'{self.description} cannot encode character {_exvunfwfpazrqi[_rjokoymizxbigc]!r} in {visible!r}')
+        _okuzpqmtslbyny = bytes(_dsncebznuwabyp)
+        self._validate_embedded_glyphs(_okuzpqmtslbyny, visible)
+        return _okuzpqmtslbyny
 
     def width(self, visible: str) -> float:
         try:

apdf-1.2/apdf/engine.py

@@ -0,0 +1,163 @@
+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, 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, _RED
+
+def _set_decoded_stream_data(stream: StreamObject, data: bytes) -> None:
+    try:
+        stream.set_data(data)
+    except Exception as _qimfvkudpmbtfm:
+        raise PdfReplacementError(_c('Ca' + 'nnot rewrite a content stream with its current PDF filters', _RED)) from _qimfvkudpmbtfm
+
+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]:
+    _dolsbllmxcvcmg = _deref(owner.get('/Contents'))
+    if _dolsbllmxcvcmg is None:
+        return
+    if isinstance(_dolsbllmxcvcmg, (list, ArrayObject)):
+        for _bqakijrtfdaakn in _dolsbllmxcvcmg:
+            _kttfvedgmsdpoh = _deref(_bqakijrtfdaakn)
+            if isinstance(_kttfvedgmsdpoh, StreamObject):
+                yield _kttfvedgmsdpoh
+    elif isinstance(_dolsbllmxcvcmg, StreamObject):
+        yield _dolsbllmxcvcmg
+
+def _isolated_reference(value: Any, writer: PdfWriter) -> Any:
+    value = _deref(value)
+    clone = value.clone(writer, force_duplicate=True)
+    return getattr(clone, 'indirect_reference', None) or clone
+
+def _isolate_selected_page(page: Any, writer: PdfWriter) -> None:
+    _hpzzzcblqqbfum = page.get('/Contents')
+    if _hpzzzcblqqbfum is not None:
+        page[NameObject('/Contents')] = _isolated_reference(_hpzzzcblqqbfum, writer)
+    _yaplwytvllhltw = page.get('/Resources')
+    if _yaplwytvllhltw is not None:
+        page[NameObject('/Resources')] = _isolated_reference(_yaplwytvllhltw, 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(_c('pages must cont' + 'ain ' + 'page numbers, not a bool' + 'ean', _RED))
+    if isinstance(pages, int):
+        _vloosseizdeydt = {pages}
+    elif isinstance(pages, (str, bytes)):
+        raise ValueError(_c('pages must be page numb' + 'ers; use the CLI -p option for ranges', _RED))
+    else:
+        _vloosseizdeydt = {int(page) for page in pages}
+    if not _vloosseizdeydt:
+        raise ValueError(_c('a' + 't least' + ' o' + 'ne page must be selected', _RED))
+    _itizoyugiqqlgt = sorted((page for page in _vloosseizdeydt if page < 1 or page > page_count))
+    if _itizoyugiqqlgt:
+        _rersoiglxwwowp = ', '.join((str(page) for page in _itizoyugiqqlgt))
+        raise ValueError(_c(f'page selection out of range: {_rersoiglxwwowp}; PDF has {page_count} page(s)', _RED))
+    return _vloosseizdeydt
+
+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:
+    _eiplhxbzivdjid = time.perf_counter()
+    _asqgrajlilnymb = [Replacement(str(old), str(new)) for old, new in replacements.items() if old]
+    if not _asqgrajlilnymb:
+        raise ValueError('At le' + 'ast one non-empty source string i' + 's ' + 'required')
+    _avkchisdcnfnfu = Path(input_pdf)
+    _kmbfuvsptjbvvm = Path(output_pdf)
+    if not _avkchisdcnfnfu.is_file():
+        raise PdfFileNotFoundError(f'File not found: {_avkchisdcnfnfu}')
+    _kmbfuvsptjbvvm.parent.mkdir(parents=True, exist_ok=True)
+    try:
+        _znbdymmzxdbjxz = PdfReader(_avkchisdcnfnfu, strict=False)
+    except DependencyError as _vxuekhsvigxblx:
+        raise PdfDependencyError(f"Missing dependency for encrypted PDF: {_vxuekhsvigxblx}\nPlease install it, e.g., 'uv pip install cryptography'") from _vxuekhsvigxblx
+    except PermissionError as _vxuekhsvigxblx:
+        raise PdfPermissionError(f"Permission denied when opening {_avkchisdcnfnfu}.{_c('The PDF might be opened by another application.', _RED)}") from _vxuekhsvigxblx
+    if _znbdymmzxdbjxz.is_encrypted:
+        raise PdfReplacementError(_c('Encry' + 'pted PDFs are not supported ' + 'without' + ' a password', _RED))
+    writer = PdfWriter(clone_from=_znbdymmzxdbjxz)
+    _pgqxvhnhiiuknc = _selected_page_numbers(pages, len(writer.pages))
+    _gpjfndmlmfddsg = len(_pgqxvhnhiiuknc) != len(writer.pages)
+    _xxopteijgitciy = FallbackFontRegistry(writer, explicit_font=fallback_font, enabled=font_fallback)
+    _fhjnljuqkjsjef = ReplacementReport(pages=len(writer.pages))
+    _kgjsxoleqweexl: set[str] = set()
+    _jzjtbirwyfcdkt: set[tuple[Any, ...]] = set()
+    for _jrstnpxllcbbay, _gijoksblqlrcsn in enumerate(writer.pages, start=1):
+        if _jrstnpxllcbbay not in _pgqxvhnhiiuknc:
+            continue
+        print(_c(f'Processing page {_jrstnpxllcbbay}/{_fhjnljuqkjsjef.pages}', _BLUE), file=sys.stderr)
+        if _gpjfndmlmfddsg:
+            _isolate_selected_page(_gijoksblqlrcsn, writer)
+        _rorabtaxuurlig = _deref(_gijoksblqlrcsn.get('/Resources', {}))
+        for _mbvmfdocfgxdom in _content_streams(_gijoksblqlrcsn):
+            key = _object_key(_mbvmfdocfgxdom)
+            if key in _jzjtbirwyfcdkt:
+                continue
+            _jzjtbirwyfcdkt.add(key)
+            _rewrite_stream(_mbvmfdocfgxdom, writer, _rorabtaxuurlig, _asqgrajlilnymb, preserve_advance, _fhjnljuqkjsjef, _kgjsxoleqweexl, _xxopteijgitciy, _jrstnpxllcbbay)
+        _rewrite_forms(_rorabtaxuurlig, writer, _asqgrajlilnymb, preserve_advance, _fhjnljuqkjsjef, _kgjsxoleqweexl, _jzjtbirwyfcdkt, _xxopteijgitciy, _jrstnpxllcbbay)
+    _xxopteijgitciy.finalize()
+    _fhjnljuqkjsjef.missing = [rule.old for rule in _asqgrajlilnymb if rule.old not in _kgjsxoleqweexl]
+    _fhjnljuqkjsjef.elapsed_seconds = time.perf_counter() - _eiplhxbzivdjid
+    if strict and (_fhjnljuqkjsjef.missing or _fhjnljuqkjsjef.encoding_failures):
+        _emuwckmalnjhtg = []
+        if _fhjnljuqkjsjef.missing:
+            _emuwckmalnjhtg.append(f'not found: {_fhjnljuqkjsjef.missing!r}')
+        if _fhjnljuqkjsjef.encoding_failures:
+            _emuwckmalnjhtg.append(f'encoding failures: {_fhjnljuqkjsjef.encoding_failures!r}')
+        raise PdfReplacementError('; '.join(_emuwckmalnjhtg))
+    _bmpmljfrdmkhvo: str | None = None
+    try:
+        try:
+            with tempfile.NamedTemporaryFile(mode='wb', prefix=f'.{_kmbfuvsptjbvvm.name}.', suffix='.tmp', dir=_kmbfuvsptjbvvm.parent, delete=False) as _dtbxckupjrbqnd:
+                _bmpmljfrdmkhvo = _dtbxckupjrbqnd.name
+                writer.write(_dtbxckupjrbqnd)
+            _miwiypflfwltgy = PdfReader(_bmpmljfrdmkhvo, strict=False)
+            if len(_miwiypflfwltgy.pages) != _fhjnljuqkjsjef.pages:
+                raise PdfReplacementError('Out' + 'put veri' + 'fication found a page-count mismatch')
+            os.replace(_bmpmljfrdmkhvo, _kmbfuvsptjbvvm)
+            _bmpmljfrdmkhvo = None
+        except PermissionError as _vxuekhsvigxblx:
+            raise PdfPermissionError(f'Permission denied when saving to {_kmbfuvsptjbvvm}. The PDF might be opened by another application.') from _vxuekhsvigxblx
+    finally:
+        if _bmpmljfrdmkhvo and os.path.exists(_bmpmljfrdmkhvo):
+            os.unlink(_bmpmljfrdmkhvo)
+    _fhjnljuqkjsjef.elapsed_seconds = time.perf_counter() - _eiplhxbzivdjid
+    return _fhjnljuqkjsjef
+
+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