BabelDOC 0.1.25__tar.gz → 0.1.26__tar.gz

{babeldoc-0.1.25 → babeldoc-0.1.26}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: BabelDOC
-Version: 0.1.25
+Version: 0.1.26
 Summary: Yet Another Document Translator
 Project-URL: Homepage, https://github.com/funstory-ai/BabelDOC
 Project-URL: Issues, https://github.com/funstory-ai/BabelDOC/issues
@@ -157,6 +157,8 @@ uv run babeldoc --bing --files example.pdf --files example2.pdf
 - `--disable-rich-text-translate`: Disable rich text translation (may help improve compatibility with some PDFs)
 - `--enhance-compatibility`: Enable all compatibility enhancement options (equivalent to --skip-clean --dual-translate-first --disable-rich-text-translate)
 - `--use-alternating-pages-dual`: Use alternating pages mode for dual PDF. When enabled, original and translated pages are arranged in alternate order. When disabled (default), original and translated pages are shown side by side on the same page.
+- `--watermark-output-mode`: Control watermark output mode: 'watermarked' (default) adds watermark to translated PDF, 'no_watermark' doesn't add watermark, 'both' outputs both versions.
+- `--no-watermark`: [DEPRECATED] Use --watermark-output-mode=no_watermark instead.
 
 > [!TIP]
 > - Both `--skip-clean` and `--dual-translate-first` may help improve compatibility with some PDF readers
@@ -262,6 +264,8 @@ skip-clean = false
 dual-translate-first = false
 disable-rich-text-translate = false
 use-alternating-pages-dual = false
+watermark-output-mode = "watermarked"  # Choices: "watermarked", "no_watermark", "both"
+# no-watermark = false  # DEPRECATED: Use watermark-output-mode instead
 
 # Output control
 no-dual = false

{babeldoc-0.1.25 → babeldoc-0.1.26}/README.md

@@ -122,6 +122,8 @@ uv run babeldoc --bing --files example.pdf --files example2.pdf
 - `--disable-rich-text-translate`: Disable rich text translation (may help improve compatibility with some PDFs)
 - `--enhance-compatibility`: Enable all compatibility enhancement options (equivalent to --skip-clean --dual-translate-first --disable-rich-text-translate)
 - `--use-alternating-pages-dual`: Use alternating pages mode for dual PDF. When enabled, original and translated pages are arranged in alternate order. When disabled (default), original and translated pages are shown side by side on the same page.
+- `--watermark-output-mode`: Control watermark output mode: 'watermarked' (default) adds watermark to translated PDF, 'no_watermark' doesn't add watermark, 'both' outputs both versions.
+- `--no-watermark`: [DEPRECATED] Use --watermark-output-mode=no_watermark instead.
 
 > [!TIP]
 > - Both `--skip-clean` and `--dual-translate-first` may help improve compatibility with some PDF readers
@@ -227,6 +229,8 @@ skip-clean = false
 dual-translate-first = false
 disable-rich-text-translate = false
 use-alternating-pages-dual = false
+watermark-output-mode = "watermarked"  # Choices: "watermarked", "no_watermark", "both"
+# no-watermark = false  # DEPRECATED: Use watermark-output-mode instead
 
 # Output control
 no-dual = false

babeldoc-0.1.26/babeldoc/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.26"

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/const.py

@@ -2,7 +2,7 @@ import shutil
 import subprocess
 from pathlib import Path
 
-__version__ = "0.1.25"
+__version__ = "0.1.26"
 
 CACHE_FOLDER = Path.home() / ".cache" / "babeldoc"
 

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/document_il/backend/pdf_creater.py

@@ -12,6 +12,7 @@ from babeldoc.document_il import il_version_1
 from babeldoc.document_il.utils.fontmap import FontMapper
 from babeldoc.translation_config import TranslateResult
 from babeldoc.translation_config import TranslationConfig
+from babeldoc.translation_config import WatermarkOutputMode
 
 logger = logging.getLogger(__name__)
 
@@ -416,8 +417,9 @@ class PDFCreater:
             pdf = self.subset_fonts_in_subprocess(pdf, translation_config, tag="debug")
         return pdf
 
+    @staticmethod
     def subset_fonts_in_subprocess(
-        self, pdf: pymupdf.Document, translation_config: TranslationConfig, tag: str
+        pdf: pymupdf.Document, translation_config: TranslationConfig, tag: str
     ) -> pymupdf.Document:
         """Run font subsetting in a subprocess with timeout.
 
@@ -489,8 +491,8 @@ class PDFCreater:
             )
             return original_pdf
 
+    @staticmethod
     def save_pdf_with_timeout(
-        self,
         pdf: pymupdf.Document,
         output_path: str,
         translation_config: TranslationConfig,
@@ -634,6 +636,8 @@ class PDFCreater:
     def write(self, translation_config: TranslationConfig) -> TranslateResult:
         basename = Path(translation_config.input_file).stem
         debug_suffix = ".debug" if translation_config.debug else ""
+        if translation_config.watermark_output_mode != WatermarkOutputMode.Watermarked:
+            debug_suffix += ".no_watermark"
         mono_out_path = translation_config.get_output_file_path(
             f"{basename}{debug_suffix}.{translation_config.lang_out}.mono.pdf",
         )

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/document_il/midend/typesetting.py

@@ -15,6 +15,7 @@ from babeldoc.document_il import PdfStyle
 from babeldoc.document_il import il_version_1
 from babeldoc.document_il.utils.fontmap import FontMapper
 from babeldoc.translation_config import TranslationConfig
+from babeldoc.translation_config import WatermarkOutputMode
 
 logger = logging.getLogger(__name__)
 
@@ -450,7 +451,11 @@ class Typesetting:
             fonts[xobj.xobj_id] = page_fonts.copy()
             for font in xobj.pdf_font:
                 fonts[xobj.xobj_id][font.font_id] = font
-        if page.page_number == 0:
+        if (
+            page.page_number == 0
+            and self.translation_config.watermark_output_mode
+            == WatermarkOutputMode.Watermarked
+        ):
             self.add_watermark(page)
         # 开始实际的渲染过程
         for paragraph in page.pdf_paragraph:

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/docvision/doclayout.py

@@ -192,7 +192,7 @@ class OnnxModel(DocLayoutModel):
         boxes[..., :4] = (boxes[..., :4] - [pad_x, pad_y, pad_x, pad_y]) / gain
         return boxes
 
-    def predict(self, image, imgsz=1024, batch_size=16, **kwargs):
+    def predict(self, image, imgsz=800, batch_size=16, **kwargs):
         """
         Predict the layout of document pages.
 

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/high_level.py

@@ -1,6 +1,9 @@
 import asyncio
+import copy
 import hashlib
+import io
 import logging
+import pathlib
 import threading
 import time
 from asyncio import CancelledError
@@ -19,6 +22,7 @@ from babeldoc import asynchronize
 from babeldoc.assets.assets import warmup
 from babeldoc.const import CACHE_FOLDER
 from babeldoc.converter import TranslateConverter
+from babeldoc.document_il import il_version_1
 from babeldoc.document_il.backend.pdf_creater import SAVE_PDF_STAGE_NAME
 from babeldoc.document_il.backend.pdf_creater import SUBSET_FONT_STAGE_NAME
 from babeldoc.document_il.backend.pdf_creater import PDFCreater
@@ -37,6 +41,7 @@ from babeldoc.pdfinterp import PDFPageInterpreterEx
 from babeldoc.progress_monitor import ProgressMonitor
 from babeldoc.translation_config import TranslateResult
 from babeldoc.translation_config import TranslationConfig
+from babeldoc.translation_config import WatermarkOutputMode
 
 logger = logging.getLogger(__name__)
 
@@ -365,6 +370,13 @@ def do_translate(pm, translation_config):
                 docs,
                 translation_config.get_working_file_path("add_debug_information.json"),
             )
+        mono_watermark_first_page_doc_bytes = None
+        dual_watermark_first_page_doc_bytes = None
+
+        if translation_config.watermark_output_mode == WatermarkOutputMode.Both:
+            mono_watermark_first_page_doc_bytes, dual_watermark_first_page_doc_bytes = (
+                generate_first_page_with_watermark(doc_input, translation_config, docs)
+            )
 
         Typesetting(translation_config).typsetting_document(docs)
         logger.debug(f"finish typsetting from {temp_pdf_path}")
@@ -377,6 +389,22 @@ def do_translate(pm, translation_config):
         # docs2 = xml_converter.deepcopy(docs)
         pdf_creater = PDFCreater(temp_pdf_path, docs, translation_config)
         result = pdf_creater.write(translation_config)
+
+        if mono_watermark_first_page_doc_bytes:
+            mono_watermark_pdf = merge_watermark_doc(
+                result.mono_pdf_path,
+                mono_watermark_first_page_doc_bytes,
+                translation_config,
+            )
+            result.mono_pdf_path = mono_watermark_pdf
+        if dual_watermark_first_page_doc_bytes:
+            dual_watermark_pdf = merge_watermark_doc(
+                result.dual_pdf_path,
+                dual_watermark_first_page_doc_bytes,
+                translation_config,
+            )
+            result.dual_pdf_path = dual_watermark_pdf
+
         finish_time = time.time()
         result.original_pdf_path = original_pdf_path
         result.total_seconds = finish_time - start_time
@@ -395,6 +423,85 @@ def do_translate(pm, translation_config):
         translation_config.cleanup_temp_files()
 
 
+def generate_first_page_with_watermark(
+    mupdf: Document,
+    translation_config: TranslationConfig,
+    doc_il: il_version_1.Document,
+) -> (io.BytesIO, io.BytesIO):
+    first_page_doc = Document()
+    first_page_doc.insert_pdf(mupdf, from_page=0, to_page=0)
+
+    il_only_first_page_doc = il_version_1.Document()
+    il_only_first_page_doc.total_pages = 1
+    il_only_first_page_doc.page = [copy.deepcopy(doc_il.page[0])]
+
+    watermarked_config = copy.copy(translation_config)
+    watermarked_config.watermark_output_mode = WatermarkOutputMode.Watermarked
+    watermarked_config.progress_monitor.disable = True
+    watermarked_temp_pdf_path = watermarked_config.get_working_file_path(
+        "watermarked_temp_input.pdf"
+    )
+    first_page_doc.save(watermarked_temp_pdf_path)
+
+    Typesetting(watermarked_config).typsetting_document(il_only_first_page_doc)
+    pdf_creater = PDFCreater(
+        watermarked_temp_pdf_path.as_posix(), il_only_first_page_doc, watermarked_config
+    )
+    result = pdf_creater.write(watermarked_config)
+    watermarked_config.progress_monitor.disable = False
+    mono_pdf_bytes = None
+    dual_pdf_bytes = None
+    if result.mono_pdf_path:
+        mono_pdf_bytes = io.BytesIO()
+        with Path(result.mono_pdf_path).open("rb") as f:
+            mono_pdf_bytes.write(f.read())
+        result.mono_pdf_path.unlink()
+        mono_pdf_bytes.seek(0)
+
+    if result.dual_pdf_path:
+        dual_pdf_bytes = io.BytesIO()
+        with Path(result.dual_pdf_path).open("rb") as f:
+            dual_pdf_bytes.write(f.read())
+        result.dual_pdf_path.unlink()
+        dual_pdf_bytes.seek(0)
+
+    return mono_pdf_bytes, dual_pdf_bytes
+
+
+def merge_watermark_doc(
+    no_watermark_pdf_path: pathlib.PosixPath,
+    watermark_first_page_pdf_bytes: io.BytesIO,
+    translation_config: TranslationConfig,
+) -> pathlib.PosixPath:
+    if not no_watermark_pdf_path.exists():
+        raise FileNotFoundError(
+            f"no_watermark_pdf_path not found: {no_watermark_pdf_path}"
+        )
+    if not watermark_first_page_pdf_bytes:
+        raise FileNotFoundError(
+            f"watermark_first_page_pdf_bytes not found: {watermark_first_page_pdf_bytes}"
+        )
+
+    no_watermark_pdf = Document(no_watermark_pdf_path.as_posix())
+    no_watermark_pdf.delete_page(0)
+
+    watermark_first_page_pdf = Document("pdf", watermark_first_page_pdf_bytes)
+    no_watermark_pdf.insert_pdf(
+        watermark_first_page_pdf, from_page=0, to_page=0, start_at=0
+    )
+
+    new_save_path = no_watermark_pdf_path.with_name(
+        no_watermark_pdf_path.name.replace(".no_watermark", "")
+    )
+
+    PDFCreater.save_pdf_with_timeout(
+        no_watermark_pdf,
+        new_save_path.as_posix(),
+        translation_config=translation_config,
+    )
+    return new_save_path
+
+
 def download_font_assets():
     warmup()
 

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/main.py

@@ -21,9 +21,10 @@ from babeldoc.document_il.translator.translator import set_translate_rate_limite
 from babeldoc.docvision.doclayout import DocLayoutModel
 from babeldoc.docvision.rpc_doclayout import RpcDocLayoutModel
 from babeldoc.translation_config import TranslationConfig
+from babeldoc.translation_config import WatermarkOutputMode
 
 logger = logging.getLogger(__name__)
-__version__ = "0.1.25"
+__version__ = "0.1.26"
 
 
 def create_parser():
@@ -169,6 +170,18 @@ def create_parser():
         action="store_true",
         help="Use alternating pages mode for dual PDF. When enabled, original and translated pages are arranged in alternate order.",
     )
+    translation_group.add_argument(
+        "--watermark-output-mode",
+        type=str,
+        choices=["watermarked", "no_watermark", "both"],
+        default="watermarked",
+        help="Control watermark output mode: 'watermarked' (default) adds watermark to translated PDF, 'no_watermark' doesn't add watermark, 'both' outputs both versions.",
+    )
+    translation_group.add_argument(
+        "--no-watermark",
+        action="store_true",
+        help="[DEPRECATED] Use --watermark-output-mode=no_watermark instead. Do not add watermark to the translated PDF.",
+    )
     translation_group.add_argument(
         "--report-interval",
         type=float,
@@ -336,6 +349,11 @@ async def main():
             use_alternating_pages_dual=args.use_alternating_pages_dual,
             report_interval=args.report_interval,
             min_text_length=args.min_text_length,
+            watermark_output_mode=(
+                WatermarkOutputMode.NoWatermark
+                if args.no_watermark
+                else getattr(WatermarkOutputMode, args.watermark_output_mode.title())
+            ),
         )
 
         # Create progress handler
@@ -349,11 +367,7 @@ async def main():
                     logger.debug(event)
                 if event["type"] == "finish":
                     result = event["translate_result"]
-                    logger.info("Translation Result:")
-                    logger.info(f"  Original PDF: {result.original_pdf_path}")
-                    logger.info(f"  Time Cost: {result.total_seconds:.2f}s")
-                    logger.info(f"  Mono PDF: {result.mono_pdf_path or 'None'}")
-                    logger.info(f"  Dual PDF: {result.dual_pdf_path or 'None'}")
+                    logger.info(str(result))
                     break
 
 

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/progress_monitor.py

@@ -35,6 +35,7 @@ class ProgressMonitor:
         self.finish_event = finish_event
         self.cancel_event = cancel_event
         self.loop = loop
+        self.disable = False
         if finish_event and not loop:
             raise ValueError("finish_event requires a loop")
         if self.progress_change_callback:
@@ -51,6 +52,8 @@ class ProgressMonitor:
         self.lock = threading.Lock()
 
     def stage_start(self, stage_name: str, total: int):
+        if self.disable:
+            return DummyTranslationStage(stage_name, total, self, 0)
         stage = self.stage[stage_name]
         stage.run_time += 1
         stage.name = stage_name
@@ -78,6 +81,8 @@ class ProgressMonitor:
         logger.debug("ProgressMonitor __exit__")
 
     def on_finish(self):
+        if self.disable:
+            return
         if self.cancel_event:
             self.cancel_event.set()
         if self.finish_event and self.loop:
@@ -86,6 +91,8 @@ class ProgressMonitor:
             self.finish_callback(type="error", error=CancelledError)
 
     def stage_done(self, stage):
+        if self.disable:
+            return
         self.last_report_time = 0.0
         self.finish_stage_count += 1
         if (
@@ -128,6 +135,8 @@ class ProgressMonitor:
         return progress
 
     def stage_update(self, stage, n: int):
+        if self.disable:
+            return
         with self.lock:
             report_time_delta = time.time() - self.last_report_time
             if report_time_delta < self.report_interval and stage.total > 3:
@@ -144,10 +153,14 @@ class ProgressMonitor:
                 self.last_report_time = time.time()
 
     def translate_done(self, translate_result):
+        if self.disable:
+            return
         if self.finish_callback:
             self.finish_callback(type="finish", translate_result=translate_result)
 
     def translate_error(self, error):
+        if self.disable:
+            return
         if self.finish_callback:
             self.finish_callback(type="error", error=error)
 
@@ -156,6 +169,8 @@ class ProgressMonitor:
             raise asyncio.CancelledError
 
     def cancel(self):
+        if self.disable:
+            return
         if self.cancel_event:
             logger.info("Translation canceled")
             self.cancel_event.set()
@@ -180,3 +195,21 @@ class TranslationStage:
     def advance(self, n: int = 1):
         self.current += n
         self.pm.stage_update(self, n)
+
+
+class DummyTranslationStage:
+    def __init__(self, name: str, total: int, pm: ProgressMonitor, weight: float):
+        self.name = name
+        self.display_name = name
+        self.current = 0
+        self.total = total
+        self.pm = pm
+
+    def __enter__(self):
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        pass
+
+    def advance(self, n: int = 1):
+        pass

{babeldoc-0.1.25 → babeldoc-0.1.26}/babeldoc/translation_config.py

@@ -1,3 +1,4 @@
+import enum
 import logging
 import shutil
 import tempfile
@@ -12,6 +13,12 @@ from babeldoc.progress_monitor import ProgressMonitor
 logger = logging.getLogger(__name__)
 
 
+class WatermarkOutputMode(enum.Enum):
+    Watermarked = "watermarked"
+    NoWatermark = "no_watermark"
+    Both = "both"
+
+
 class TranslationConfig:
     def __init__(
         self,
@@ -43,6 +50,7 @@ class TranslationConfig:
         min_text_length: int = 5,
         use_side_by_side_dual: bool = True,  # Deprecated: 是否使用拼版式双语 PDF（并排显示原文和译文） 向下兼容选项，已停用。
         use_alternating_pages_dual: bool = False,
+        watermark_output_mode: WatermarkOutputMode = WatermarkOutputMode.Watermarked,
     ):
         self.translator = translator
 
@@ -55,6 +63,7 @@ class TranslationConfig:
         self.pages = pages
         self.page_ranges = self._parse_pages(pages) if pages else None
         self.debug = debug
+        self.watermark_output_mode = watermark_output_mode
 
         self.output_dir = output_dir
         self.working_dir = working_dir
@@ -175,7 +184,52 @@ class TranslateResult:
     total_seconds: float
     mono_pdf_path: str | None
     dual_pdf_path: str | None
+    no_watermark_mono_pdf_path: str | None
+    no_watermark_dual_pdf_path: str | None
 
     def __init__(self, mono_pdf_path: str | None, dual_pdf_path: str | None):
         self.mono_pdf_path = mono_pdf_path
         self.dual_pdf_path = dual_pdf_path
+
+        # For compatibility considerations, if only a non-watermarked PDF is generated,
+        # the values of mono_pdf_path and no_watermark_mono_pdf_path are the same.
+        self.no_watermark_mono_pdf_path = mono_pdf_path
+        self.no_watermark_dual_pdf_path = dual_pdf_path
+
+    def __str__(self):
+        """Return a human-readable string representation of the translation result."""
+        result = []
+        if hasattr(self, "original_pdf_path") and self.original_pdf_path:
+            result.append(f"\tOriginal PDF: {self.original_pdf_path}")
+
+        if hasattr(self, "total_seconds") and self.total_seconds:
+            result.append(f"\tTotal time: {self.total_seconds:.2f} seconds")
+
+        if self.mono_pdf_path:
+            result.append(f"\tMonolingual PDF: {self.mono_pdf_path}")
+
+        if self.dual_pdf_path:
+            result.append(f"\tDual-language PDF: {self.dual_pdf_path}")
+
+        if (
+            hasattr(self, "no_watermark_mono_pdf_path")
+            and self.no_watermark_mono_pdf_path
+            and self.no_watermark_mono_pdf_path != self.mono_pdf_path
+        ):
+            result.append(
+                f"\tNo-watermark Monolingual PDF: {self.no_watermark_mono_pdf_path}"
+            )
+
+        if (
+            hasattr(self, "no_watermark_dual_pdf_path")
+            and self.no_watermark_dual_pdf_path
+            and self.no_watermark_dual_pdf_path != self.dual_pdf_path
+        ):
+            result.append(
+                f"\tNo-watermark Dual-language PDF: {self.no_watermark_dual_pdf_path}"
+            )
+
+        if result:
+            result.insert(0, "Translation results:")
+
+        return "\n".join(result) if result else "No translation results available"

{babeldoc-0.1.25 → babeldoc-0.1.26}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "BabelDOC"
-version = "0.1.25"
+version = "0.1.26"
 description = "Yet Another Document Translator"
 license = "AGPL-3.0"
 readme = "README.md"
@@ -133,7 +133,7 @@ pythonpath = [".", "src"]
 testpaths = ["tests"]
 
 [bumpver]
-current_version = "0.1.25"
+current_version = "0.1.26"
 version_pattern = "MAJOR.MINOR.PATCH[.PYTAGNUM]"
 
 [bumpver.file_patterns]

{babeldoc-0.1.25 → babeldoc-0.1.26}/uv.lock

@@ -48,7 +48,7 @@ wheels = [
 
 [[package]]
 name = "babeldoc"
-version = "0.1.25"
+version = "0.1.26"
 source = { editable = "." }
 dependencies = [
     { name = "bitstring" },

babeldoc-0.1.25/babeldoc/__init__.py

@@ -1 +0,0 @@
-__version__ = "0.1.25"