Files
PDFReaderLite/pdfreaderlite/core/document.py
T

431 lines
15 KiB
Python

from __future__ import annotations
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
class EncryptedPdfError(RuntimeError):
pass
class PdfDocument:
def __init__(self) -> None:
self.path: Path | None = None
self._doc: fitz.Document | None = None
@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 需要密码。")
def close(self) -> None:
if self._doc:
self._doc.close()
self._doc = None
self.path = None
def render_page(self, page_index: int, zoom: float) -> QImage:
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,
)
return image.copy()
def render_thumbnail(self, page_index: int, width: int = 150) -> QImage:
page = self._page(page_index)
rect = page.rect
zoom = width / rect.width
return self.render_page(page_index, zoom)
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:
page = self._page(page_index)
page.set_rotation((page.rotation + degrees) % 360)
def highlight_text(self, page_index: int, text: str) -> int:
page = self._page(page_index)
rects = page.search_for(text.strip())
for rect in rects:
annot = page.add_highlight_annot(rect)
annot.update()
return len(rects)
def underline_text(self, page_index: int, text: str) -> int:
page = self._page(page_index)
rects = page.search_for(text.strip())
for rect in rects:
annot = page.add_underline_annot(rect)
annot.update()
return len(rects)
def strikeout_text(self, page_index: int, text: str) -> int:
page = self._page(page_index)
rects = page.search_for(text.strip())
for rect in rects:
annot = page.add_strikeout_annot(rect)
annot.update()
return len(rects)
def add_note(self, page_index: int, text: str) -> None:
page = self._page(page_index)
point = fitz.Point(72, 72)
annot = page.add_text_annot(point, text)
annot.update()
def add_text(self, page_index: int, text: str) -> None:
page = self._page(page_index)
point = fitz.Point(72, 96)
page.insert_text(point, text, fontsize=14, fontname="china-s", color=(0, 0, 0))
def insert_image(self, page_index: int, image_path: str | Path) -> None:
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)
def add_signature(self, page_index: int, image_path: str | Path) -> None:
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)
def add_rectangle(self, page_index: int) -> None:
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()
def add_circle(self, page_index: int) -> None:
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()
def add_line(self, page_index: int, arrow: bool = False) -> None:
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()
def add_cover_area(self, page_index: int) -> None:
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()
def insert_blank_page(self, after_page_index: int | None = None) -> int:
if not self._doc:
raise RuntimeError("没有打开 PDF")
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)
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")
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)
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")
metadata = self.metadata()
metadata.update(
{
"title": title,
"author": author,
"subject": subject,
"keywords": keywords,
}
)
self._doc.set_metadata(metadata)
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:
widget.field_value = value
widget.update()
return True
return False
def delete_page(self, page_index: int) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
self._doc.delete_page(page_index)
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
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)
if original_path and target.resolve() == original_path.resolve():
self._doc.close()
self._doc = None
temp_path.replace(target)
self.path = target
if self._doc:
self._doc.close()
self._doc = fitz.open(target)
finally:
if temp_path.exists():
temp_path.unlink()
def save_encrypted(self, path: str | Path, password: str) -> None:
if not self._doc:
raise RuntimeError("没有打开 PDF")
if not password:
raise ValueError("密码不能为空")
target = Path(path)
target.parent.mkdir(parents=True, exist_ok=True)
self._doc.save(
target,
garbage=4,
deflate=True,
encryption=fitz.PDF_ENCRYPT_AES_256,
owner_pw=password,
user_pw=password,
permissions=fitz.PDF_PERM_ACCESSIBILITY | fitz.PDF_PERM_PRINT,
)
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)
@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)