from __future__ import annotations from collections import OrderedDict from dataclasses import dataclass from pathlib import Path from tempfile import NamedTemporaryFile import fitz from PySide6.QtGui import QImage @dataclass(frozen=True) class SearchMatch: page_index: int text: str @dataclass(frozen=True) class FormField: page_index: int name: str field_type: str value: str @dataclass(frozen=True) class AnnotationInfo: page_index: int xref: int annotation_type: str content: str class EncryptedPdfError(RuntimeError): pass class PdfDocument: def __init__(self) -> None: self.path: Path | None = None self._doc: fitz.Document | None = None self._revision = 0 self._undo_stack: list[bytes] = [] self._redo_stack: list[bytes] = [] self._render_cache: OrderedDict[tuple[int, int, float], QImage] = OrderedDict() self._thumbnail_cache: OrderedDict[tuple[int, int, int], QImage] = OrderedDict() @property def is_open(self) -> bool: return self._doc is not None @property def page_count(self) -> int: return len(self._doc) if self._doc else 0 @property def title(self) -> str: if not self.path: return "未打开文档" return self.path.name def open(self, path: str | Path, password: str | None = None) -> None: self.close() self.path = Path(path) self._doc = fitz.open(self.path) if self._doc.needs_pass: if not password or not self._doc.authenticate(password): self.close() raise EncryptedPdfError("该 PDF 需要密码。") self.clear_history() def close(self) -> None: if self._doc: self._doc.close() self._doc = None self.path = None self.clear_history() self.clear_cache() def render_page(self, page_index: int, zoom: float) -> QImage: cache_key = (self._revision, page_index, round(zoom, 3)) if cache_key in self._render_cache: self._render_cache.move_to_end(cache_key) return self._render_cache[cache_key].copy() page = self._page(page_index) matrix = fitz.Matrix(zoom, zoom) pixmap = page.get_pixmap(matrix=matrix, alpha=False) image = QImage( pixmap.samples, pixmap.width, pixmap.height, pixmap.stride, QImage.Format.Format_RGB888, ) cached = image.copy() self._remember_cache_item(self._render_cache, cache_key, cached, max_items=16) return cached.copy() def render_thumbnail(self, page_index: int, width: int = 150) -> QImage: cache_key = (self._revision, page_index, width) if cache_key in self._thumbnail_cache: self._thumbnail_cache.move_to_end(cache_key) return self._thumbnail_cache[cache_key].copy() page = self._page(page_index) rect = page.rect zoom = width / rect.width thumbnail = self.render_page(page_index, zoom) self._remember_cache_item(self._thumbnail_cache, cache_key, thumbnail, max_items=80) return thumbnail.copy() def search(self, text: str, limit: int = 200) -> list[SearchMatch]: if not self._doc or not text.strip(): return [] matches: list[SearchMatch] = [] query = text.strip() for page_index, page in enumerate(self._doc): if page.search_for(query): page_text = page.get_text("text").replace("\n", " ") snippet_index = page_text.lower().find(query.lower()) if snippet_index >= 0: start = max(0, snippet_index - 24) end = min(len(page_text), snippet_index + len(query) + 48) snippet = page_text[start:end].strip() else: snippet = f"第 {page_index + 1} 页匹配" matches.append(SearchMatch(page_index=page_index, text=snippet)) if len(matches) >= limit: break return matches def rotate_page(self, page_index: int, degrees: int = 90) -> None: self.snapshot() page = self._page(page_index) page.set_rotation((page.rotation + degrees) % 360) self.mark_changed() def highlight_text(self, page_index: int, text: str) -> int: page = self._page(page_index) rects = page.search_for(text.strip()) if rects: self.snapshot() for rect in rects: annot = page.add_highlight_annot(rect) annot.update() if rects: self.mark_changed() return len(rects) def underline_text(self, page_index: int, text: str) -> int: page = self._page(page_index) rects = page.search_for(text.strip()) if rects: self.snapshot() for rect in rects: annot = page.add_underline_annot(rect) annot.update() if rects: self.mark_changed() return len(rects) def strikeout_text(self, page_index: int, text: str) -> int: page = self._page(page_index) rects = page.search_for(text.strip()) if rects: self.snapshot() for rect in rects: annot = page.add_strikeout_annot(rect) annot.update() if rects: self.mark_changed() return len(rects) def add_note(self, page_index: int, text: str) -> None: self.snapshot() page = self._page(page_index) point = fitz.Point(72, 72) annot = page.add_text_annot(point, text) annot.update() self.mark_changed() def add_text(self, page_index: int, text: str) -> None: self.snapshot() page = self._page(page_index) point = fitz.Point(72, 96) page.insert_text(point, text, fontsize=14, fontname="china-s", color=(0, 0, 0)) self.mark_changed() def insert_image(self, page_index: int, image_path: str | Path) -> None: self.snapshot() page = self._page(page_index) page_rect = page.rect width = page_rect.width * 0.35 height = width * 0.75 rect = fitz.Rect(72, 120, 72 + width, 120 + height) page.insert_image(rect, filename=str(image_path), keep_proportion=True) self.mark_changed() def add_signature(self, page_index: int, image_path: str | Path) -> None: self.snapshot() page = self._page(page_index) page_rect = page.rect width = page_rect.width * 0.28 height = width * 0.42 margin = 54 rect = fitz.Rect( page_rect.width - width - margin, page_rect.height - height - margin, page_rect.width - margin, page_rect.height - margin, ) page.insert_image(rect, filename=str(image_path), keep_proportion=True) self.mark_changed() def add_rectangle(self, page_index: int) -> None: self.snapshot() page = self._page(page_index) rect = self._default_rect(page) annot = page.add_rect_annot(rect) annot.set_colors(stroke=(0.9, 0.1, 0.1)) annot.set_border(width=2) annot.update() self.mark_changed() def add_circle(self, page_index: int) -> None: self.snapshot() page = self._page(page_index) rect = self._default_rect(page) annot = page.add_circle_annot(rect) annot.set_colors(stroke=(0.1, 0.3, 0.9)) annot.set_border(width=2) annot.update() self.mark_changed() def add_line(self, page_index: int, arrow: bool = False) -> None: self.snapshot() page = self._page(page_index) rect = self._default_rect(page) start = fitz.Point(rect.x0, rect.y0) end = fitz.Point(rect.x1, rect.y1) annot = page.add_line_annot(start, end) annot.set_colors(stroke=(0.1, 0.1, 0.1)) annot.set_border(width=2) if arrow: annot.set_line_ends(fitz.PDF_ANNOT_LE_NONE, fitz.PDF_ANNOT_LE_CLOSED_ARROW) annot.update() self.mark_changed() def add_ink(self, page_index: int, points: list[tuple[float, float]]) -> None: if len(points) < 2: return self.snapshot() page = self._page(page_index) stroke = [(float(x), float(y)) for x, y in points] annot = page.add_ink_annot([stroke]) annot.set_colors(stroke=(0.05, 0.05, 0.05)) annot.set_border(width=2) annot.update() self.mark_changed() def add_cover_area(self, page_index: int) -> None: self.snapshot() page = self._page(page_index) rect = self._default_rect(page) annot = page.add_rect_annot(rect) annot.set_colors(stroke=(1, 1, 1), fill=(1, 1, 1)) annot.set_border(width=0) annot.update() self.mark_changed() def insert_blank_page(self, after_page_index: int | None = None) -> int: if not self._doc: raise RuntimeError("没有打开 PDF") self.snapshot() if self.page_count: source = self._page(after_page_index if after_page_index is not None else self.page_count - 1) width = source.rect.width height = source.rect.height else: width = 595 height = 842 insert_at = self.page_count if after_page_index is None else after_page_index + 1 self._doc.new_page(pno=insert_at, width=width, height=height) self.mark_changed() return insert_at def insert_pdf(self, source_path: str | Path, after_page_index: int | None = None) -> int: if not self._doc: raise RuntimeError("没有打开 PDF") self.snapshot() insert_at = self.page_count if after_page_index is None else after_page_index + 1 with fitz.open(source_path) as source: count = source.page_count self._doc.insert_pdf(source, start_at=insert_at) self.mark_changed() return count def extract_pages(self, page_numbers: list[int], target_path: str | Path) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") new_doc = fitz.open() try: for page_number in page_numbers: page_index = page_number - 1 if page_index < 0 or page_index >= self.page_count: raise ValueError(f"页码超出范围:{page_number}") new_doc.insert_pdf(self._doc, from_page=page_index, to_page=page_index) new_doc.save(target_path, garbage=4, deflate=True) finally: new_doc.close() def split_to_folder(self, target_folder: str | Path) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") folder = Path(target_folder) folder.mkdir(parents=True, exist_ok=True) base_name = self.path.stem if self.path else "PDFReaderLite" for page_index in range(self.page_count): new_doc = fitz.open() try: new_doc.insert_pdf(self._doc, from_page=page_index, to_page=page_index) new_doc.save(folder / f"{base_name}_第{page_index + 1}页.pdf", garbage=4, deflate=True) finally: new_doc.close() @staticmethod def merge_pdfs(source_paths: list[str | Path], target_path: str | Path) -> None: if not source_paths: raise ValueError("没有选择 PDF 文件") merged = fitz.open() try: for source_path in source_paths: with fitz.open(source_path) as source: merged.insert_pdf(source) merged.save(target_path, garbage=4, deflate=True) finally: merged.close() def export_page_image(self, page_index: int, target_path: str | Path, zoom: float = 2.0) -> None: page = self._page(page_index) pixmap = page.get_pixmap(matrix=fitz.Matrix(zoom, zoom), alpha=False) pixmap.save(target_path) def export_pages_images( self, page_numbers: list[int], target_folder: str | Path, zoom: float = 2.0, ) -> None: folder = Path(target_folder) folder.mkdir(parents=True, exist_ok=True) base_name = self.path.stem if self.path else "PDFReaderLite" for page_number in page_numbers: page_index = page_number - 1 if page_index < 0 or page_index >= self.page_count: raise ValueError(f"页码超出范围:{page_number}") self.export_page_image(page_index, folder / f"{base_name}_第{page_number}页.png", zoom) @staticmethod def images_to_pdf(image_paths: list[str | Path], target_path: str | Path) -> None: if not image_paths: raise ValueError("没有选择图片文件") document = fitz.open() try: for image_path in image_paths: image_doc = fitz.open(image_path) try: rect = image_doc[0].rect pdf_bytes = image_doc.convert_to_pdf() finally: image_doc.close() image_pdf = fitz.open("pdf", pdf_bytes) try: page = document.new_page(width=rect.width, height=rect.height) page.show_pdf_page(page.rect, image_pdf, 0) finally: image_pdf.close() document.save(target_path, garbage=4, deflate=True) finally: document.close() def metadata(self) -> dict[str, str]: if not self._doc: raise RuntimeError("没有打开 PDF") return {key: value or "" for key, value in self._doc.metadata.items()} def update_metadata( self, title: str = "", author: str = "", subject: str = "", keywords: str = "", ) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") self.snapshot() metadata = self.metadata() metadata.update( { "title": title, "author": author, "subject": subject, "keywords": keywords, } ) self._doc.set_metadata(metadata) self.mark_changed() def annotations(self) -> list[AnnotationInfo]: if not self._doc: raise RuntimeError("没有打开 PDF") items: list[AnnotationInfo] = [] for page_index in range(self.page_count): page = self._page(page_index) annot = page.first_annot while annot: content = annot.info.get("content", "") if annot.info else "" items.append( AnnotationInfo( page_index=page_index, xref=annot.xref, annotation_type=annot.type[1], content=content, ) ) annot = annot.next return items def delete_annotation(self, page_index: int, xref: int) -> bool: page = self._page(page_index) annot = page.first_annot while annot: if annot.xref == xref: self.snapshot() page.delete_annot(annot) self.mark_changed() return True annot = annot.next return False def form_fields(self) -> list[FormField]: if not self._doc: raise RuntimeError("没有打开 PDF") fields: list[FormField] = [] for page_index in range(self.page_count): widgets = self._page(page_index).widgets() or [] for widget in widgets: name = widget.field_name or "" if not name: continue fields.append( FormField( page_index=page_index, name=name, field_type=widget.field_type_string or "", value=str(widget.field_value or ""), ) ) return fields def update_form_field(self, field_name: str, value: str) -> bool: if not self._doc: raise RuntimeError("没有打开 PDF") for page_index in range(self.page_count): widgets = self._page(page_index).widgets() or [] for widget in widgets: if widget.field_name == field_name: self.snapshot() widget.field_value = value widget.update() self.mark_changed() return True return False def delete_page(self, page_index: int) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") self.snapshot() self._doc.delete_page(page_index) self.mark_changed() def move_page(self, from_page_index: int, to_page_index: int) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") if from_page_index < 0 or from_page_index >= self.page_count: raise IndexError("源页码超出范围") if to_page_index < 0 or to_page_index >= self.page_count: raise IndexError("目标页码超出范围") if from_page_index == to_page_index: return self.snapshot() self._doc.move_page(from_page_index, to_page_index) self.mark_changed() def reorder_pages(self, page_order: list[int]) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") if sorted(page_order) != list(range(self.page_count)): raise ValueError("页面顺序必须包含所有页面且不能重复") if page_order == list(range(self.page_count)): return self.snapshot() reordered = fitz.open() try: for page_index in page_order: reordered.insert_pdf(self._doc, from_page=page_index, to_page=page_index) data = reordered.tobytes(garbage=4, deflate=True) finally: reordered.close() self._replace_with_bytes(data) def save(self) -> None: if not self.path: raise RuntimeError("没有原始文件路径") self.save_as(self.path) def save_as(self, path: str | Path) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") target = Path(path) target.parent.mkdir(parents=True, exist_ok=True) original_path = self.path can_incremental = ( original_path and target.resolve() == original_path.resolve() and self._doc.name and Path(self._doc.name).resolve() == target.resolve() ) if can_incremental: self._doc.saveIncr() self._doc.close() self.path = target self._doc = fitz.open(target) self.mark_changed() return with NamedTemporaryFile(delete=False, suffix=".pdf", dir=target.parent) as tmp: temp_path = Path(tmp.name) try: self._doc.save(temp_path, garbage=4, deflate=True) temp_path.replace(target) self.path = target if self._doc: self._doc.close() self._doc = fitz.open(target) self.mark_changed() finally: if temp_path.exists(): temp_path.unlink() def save_encrypted( self, path: str | Path, password: str, allow_print: bool = True, allow_copy: bool = True, allow_modify: bool = False, ) -> None: if not self._doc: raise RuntimeError("没有打开 PDF") if not password: raise ValueError("密码不能为空") target = Path(path) target.parent.mkdir(parents=True, exist_ok=True) permissions = fitz.PDF_PERM_ACCESSIBILITY if allow_print: permissions |= fitz.PDF_PERM_PRINT if allow_copy: permissions |= fitz.PDF_PERM_COPY if allow_modify: permissions |= fitz.PDF_PERM_MODIFY self._doc.save( target, garbage=4, deflate=True, encryption=fitz.PDF_ENCRYPT_AES_256, owner_pw=password, user_pw=password, permissions=permissions, ) def _page(self, page_index: int) -> fitz.Page: if not self._doc: raise RuntimeError("没有打开 PDF") if page_index < 0 or page_index >= len(self._doc): raise IndexError("页码超出范围") return self._doc.load_page(page_index) def mark_changed(self) -> None: self._revision += 1 self.clear_cache() def snapshot(self) -> None: if not self._doc: return self._undo_stack.append(self._doc.tobytes(garbage=4, deflate=True)) if len(self._undo_stack) > 20: self._undo_stack.pop(0) self._redo_stack.clear() def can_undo(self) -> bool: return bool(self._undo_stack) def can_redo(self) -> bool: return bool(self._redo_stack) def undo(self) -> bool: if not self._doc or not self._undo_stack: return False self._redo_stack.append(self._doc.tobytes(garbage=4, deflate=True)) data = self._undo_stack.pop() self._replace_with_bytes(data) return True def redo(self) -> bool: if not self._doc or not self._redo_stack: return False self._undo_stack.append(self._doc.tobytes(garbage=4, deflate=True)) data = self._redo_stack.pop() self._replace_with_bytes(data) return True def clear_history(self) -> None: self._undo_stack.clear() self._redo_stack.clear() def _replace_with_bytes(self, data: bytes) -> None: if self._doc: self._doc.close() self._doc = fitz.open("pdf", data) self.mark_changed() def clear_cache(self) -> None: self._render_cache.clear() self._thumbnail_cache.clear() @staticmethod def _remember_cache_item( cache: OrderedDict, key: tuple, image: QImage, max_items: int, ) -> None: cache[key] = image cache.move_to_end(key) while len(cache) > max_items: cache.popitem(last=False) @staticmethod def _default_rect(page: fitz.Page) -> fitz.Rect: width = min(220, page.rect.width * 0.45) height = min(120, page.rect.height * 0.2) x0 = max(36, page.rect.width * 0.12) y0 = max(36, page.rect.height * 0.16) return fitz.Rect(x0, y0, x0 + width, y0 + height)