repdf 0.0.8__py3-none-any.whl

repdf/assets/check.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="M3.5 8 6.5 11 12.5 5" fill="none" stroke="white" stroke-width="2" stroke-linecap="round" stroke-linejoin="round"/></svg>

repdf/assets/partial.svg

@@ -0,0 +1 @@
+<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 16 16"><path d="M4 8h8" stroke="white" stroke-width="2" stroke-linecap="round"/></svg>

repdf/core.py

@@ -0,0 +1,224 @@
+from __future__ import annotations
+
+from repdf.strings import tr
+
+import os
+import tempfile
+from dataclasses import dataclass
+from enum import Enum
+from pathlib import Path
+from typing import Iterable
+
+from pypdf import PdfReader, PdfWriter
+
+
+class RepdfError(Exception):
+    """Base error presented to the user."""
+
+
+class UnsupportedEncryptedPdfError(RepdfError):
+    """Raised when a PDF requires a password."""
+
+
+class InvalidPdfError(RepdfError):
+    """Raised when a PDF cannot be parsed."""
+
+
+class SelectionState(Enum):
+    NONE = 0
+    PARTIAL = 1
+    ALL = 2
+
+
+@dataclass(frozen=True)
+class PdfInfo:
+    path: Path
+    page_count: int
+
+
+@dataclass(frozen=True)
+class DocumentSelection:
+    source: Path
+    pages: tuple[int, ...]
+
+
+def _prepare_documents(documents: Iterable[DocumentSelection]):
+    prepared = []
+    readers = {}
+    for document in documents:
+        if not document.pages:
+            continue
+        source = Path(document.source).resolve()
+        if source not in readers:
+            if not source.is_file():
+                raise FileNotFoundError(tr('找不到來源 PDF 檔案：{p0}', p0=source))
+            readers[source] = PdfReader(source)
+        reader = readers[source]
+        if reader.is_encrypted:
+            raise UnsupportedEncryptedPdfError(tr('目前不支援密碼保護的 PDF：{p0}', p0=source))
+        if any(page < 0 or page >= len(reader.pages) for page in document.pages):
+            raise IndexError(tr('選取的頁碼超出來源 PDF 範圍：{p0}', p0=source))
+        prepared.append((source, reader, document.pages))
+    if not prepared:
+        raise ValueError(tr('請至少選取一頁。'))
+    return prepared
+
+
+def _copy_metadata(reader: PdfReader, writer: PdfWriter) -> None:
+    if reader.metadata:
+        writer.add_metadata({str(key): str(value) for key, value in reader.metadata.items()
+                             if key and value is not None})
+
+
+def indices_for_parity(page_count: int, odd: bool) -> set[int]:
+    """Return zero-based indices for human-facing odd or even page numbers."""
+    start = 0 if odd else 1
+    return set(range(start, page_count, 2))
+
+
+def parity_state(selected: set[int], page_count: int, odd: bool) -> SelectionState:
+    group = indices_for_parity(page_count, odd)
+    if not group or not (selected & group):
+        return SelectionState.NONE
+    if group <= selected:
+        return SelectionState.ALL
+    return SelectionState.PARTIAL
+
+
+def set_parity(
+    selected: set[int], page_count: int, odd: bool, enabled: bool
+) -> set[int]:
+    result = set(selected)
+    group = indices_for_parity(page_count, odd)
+    if enabled:
+        result.update(group)
+    else:
+        result.difference_update(group)
+    return result
+
+
+def default_output_path(source: str | Path) -> Path:
+    path = Path(source)
+    return path.with_name(f"{path.stem}_selected.pdf")
+
+
+def split_output_paths(destination: str | Path, count: int) -> list[Path]:
+    path = Path(destination)
+    digits = max(2, len(str(count)))
+    return [path.with_name(f"{path.stem}_{number:0{digits}d}.pdf")
+            for number in range(1, count + 1)]
+
+
+def split_selected_pages(
+    source: str | Path, destination: str | Path, selected: Iterable[int], *,
+    overwrite: bool = False,
+) -> list[Path]:
+    ordered = sorted(selected) if isinstance(selected, (set, frozenset)) else list(dict.fromkeys(selected))
+    return split_documents([DocumentSelection(Path(source), tuple(ordered))], destination,
+                           overwrite=overwrite)
+
+
+def split_documents(
+    documents: Iterable[DocumentSelection], destination: str | Path, *,
+    overwrite: bool = False, protected_sources: Iterable[Path] = (),
+) -> list[Path]:
+    prepared = _prepare_documents(documents)
+    outputs = split_output_paths(Path(destination).resolve(), sum(len(pages) for _, _, pages in prepared))
+    protected = {source for source, _, _ in prepared} | {Path(path).resolve() for path in protected_sources}
+    if protected.intersection(outputs):
+        raise ValueError(tr('輸出檔案不可覆蓋來源 PDF。'))
+    if not overwrite and any(path.exists() for path in outputs):
+        raise FileExistsError(tr('部分單頁檔案已存在，請確認覆蓋或更換檔名。'))
+    outputs[0].parent.mkdir(parents=True, exist_ok=True)
+    # Finish generating every page before publishing any output file.
+    with tempfile.TemporaryDirectory(prefix=".repdf-split-", dir=outputs[0].parent) as staging:
+        staged = []
+        ordered = [(reader, page) for _, reader, pages in prepared for page in pages]
+        for (reader, page), output in zip(ordered, outputs):
+            writer = PdfWriter()
+            writer.add_page(reader.pages[page])
+            _copy_metadata(reader, writer)
+            pending = Path(staging) / output.name
+            with pending.open("wb") as stream:
+                writer.write(stream)
+                stream.flush()
+                os.fsync(stream.fileno())
+            staged.append(pending)
+        published = 0
+        try:
+            for pending, output in zip(staged, outputs):
+                if overwrite:
+                    os.replace(pending, output)
+                elif os.name == "nt":
+                    # Windows rename is atomic and refuses an existing destination.
+                    os.rename(pending, output)
+                else:
+                    # Exclusive publication also protects against files created during export.
+                    os.link(pending, output)
+                published += 1
+        except OSError as exc:
+            raise OSError(tr('拆分輸出失敗；已完成 {p0} / {p1} 個檔案。\n{p2}', p0=published, p1=len(outputs), p2=exc)) from exc
+    return outputs
+
+
+def inspect_pdf(source: str | Path) -> PdfInfo:
+    path = Path(source).resolve()
+    if not path.is_file():
+        raise InvalidPdfError(tr('找不到來源 PDF 檔案。'))
+    try:
+        reader = PdfReader(path)
+        if reader.is_encrypted:
+            raise UnsupportedEncryptedPdfError(tr('目前不支援密碼保護的 PDF。'))
+        page_count = len(reader.pages)
+    except UnsupportedEncryptedPdfError:
+        raise
+    except Exception as exc:
+        raise InvalidPdfError(tr('無法讀取這個 PDF，檔案可能已損壞或格式不受支援。')) from exc
+    if page_count == 0:
+        raise InvalidPdfError(tr('這個 PDF 沒有可用的頁面。'))
+    return PdfInfo(path=path, page_count=page_count)
+
+
+def export_selected_pages(
+    source: str | Path, destination: str | Path, selected: Iterable[int]
+) -> int:
+    ordered = (
+        sorted(selected) if isinstance(selected, (set, frozenset))
+        else list(dict.fromkeys(selected))
+    )
+    return export_documents([DocumentSelection(Path(source), tuple(ordered))], destination)
+
+
+def export_documents(
+    documents: Iterable[DocumentSelection], destination: str | Path, *,
+    protected_sources: Iterable[Path] = (),
+) -> int:
+    prepared = _prepare_documents(documents)
+    destination_path = Path(destination).resolve()
+    protected = {source for source, _, _ in prepared} | {Path(path).resolve() for path in protected_sources}
+    if destination_path in protected:
+        raise ValueError(tr('輸出檔案不可覆蓋來源 PDF。'))
+
+    destination_path.parent.mkdir(parents=True, exist_ok=True)
+    temp_path: Path | None = None
+    try:
+        writer = PdfWriter()
+        for _, reader, pages in prepared:
+            for page_index in pages:
+                writer.add_page(reader.pages[page_index])
+        _copy_metadata(prepared[0][1], writer)
+
+        with tempfile.NamedTemporaryFile(
+            mode="wb", suffix=".pdf", prefix=".repdf-", dir=destination_path.parent,
+            delete=False,
+        ) as stream:
+            temp_path = Path(stream.name)
+            writer.write(stream)
+            stream.flush()
+            os.fsync(stream.fileno())
+        os.replace(temp_path, destination_path)
+        temp_path = None
+        return sum(len(pages) for _, _, pages in prepared)
+    finally:
+        if temp_path is not None:
+            temp_path.unlink(missing_ok=True)

repdf/entrypoint.py

@@ -0,0 +1,19 @@
+from __future__ import annotations
+
+import os
+import sys
+
+
+def main() -> int:
+    # Keep libraries that log to stderr compatible with windowed bootloaders.
+    for name in ("stdout", "stderr"):
+        if getattr(sys, name) is None:
+            setattr(sys, name, open(os.devnull, "w", encoding="utf-8"))
+    if len(sys.argv) == 4 and sys.argv[1] == "--render-server":
+        from repdf.render_worker import serve_socket
+        return serve_socket(int(sys.argv[2]), sys.argv[3])
+    if len(sys.argv) == 3 and sys.argv[1] == "--self-test":
+        from repdf.packaging_smoke import main as smoke_main
+        return smoke_main(sys.argv[2])
+    from repdf.app import main as app_main
+    return app_main()

repdf/icons.py

@@ -0,0 +1,81 @@
+"""Small, flat toolbar icons drawn at device-independent coordinates."""
+
+from PySide6.QtCore import QPointF, QRectF, Qt
+from PySide6.QtGui import QFont, QIcon, QPainter, QPainterPath, QPalette, QPen, QPixmap, QPolygonF
+from PySide6.QtWidgets import QApplication
+
+
+def toolbar_icon(kind: str) -> QIcon:
+    icon = QIcon()
+    for mode, group in ((QIcon.Mode.Normal, QPalette.ColorGroup.Active),
+                        (QIcon.Mode.Disabled, QPalette.ColorGroup.Disabled)):
+        pixmap = QPixmap(48, 48)
+        pixmap.fill(Qt.GlobalColor.transparent)
+        painter = QPainter(pixmap)
+        painter.setRenderHint(QPainter.RenderHint.Antialiasing)
+        painter.scale(2, 2)
+        painter.setPen(QPen(QApplication.palette().color(group, QPalette.ColorRole.ButtonText),
+                            1.0, Qt.PenStyle.SolidLine, Qt.PenCapStyle.RoundCap,
+                            Qt.PenJoinStyle.RoundJoin))
+        if kind in ("language_zh", "language_en"):
+            font = QFont(QApplication.font())
+            font.setPixelSize(16)
+            painter.setFont(font)
+            painter.drawText(QRectF(1, 1, 22, 22), Qt.AlignmentFlag.AlignCenter,
+                             "中" if kind == "language_zh" else "En")
+        elif kind == "language_system":
+            painter.drawEllipse(QRectF(3, 3, 18, 18))
+            painter.drawEllipse(QRectF(8, 3, 8, 18))
+            painter.drawLine(3, 12, 21, 12)
+        elif kind == "theme_system":
+            moon = QPainterPath(QPointF(8, 2))
+            moon.cubicTo(1, 1, 1, 10, 6, 10)
+            moon.cubicTo(8, 10, 9, 8, 9, 7)
+            moon.cubicTo(4, 8, 4, 4, 8, 2)
+            painter.drawPath(moon)
+            painter.drawLine(19, 2, 5, 22)
+            painter.drawEllipse(QRectF(14, 14, 6, 6))
+            for x1, y1, x2, y2 in ((17, 11, 17, 12), (17, 22, 17, 23),
+                                    (11, 17, 12, 17), (22, 17, 23, 17),
+                                    (12, 12, 13, 13), (21, 21, 22, 22),
+                                    (12, 22, 13, 21), (21, 13, 22, 12)):
+                painter.drawLine(x1, y1, x2, y2)
+        elif kind == "theme_light":
+            painter.drawEllipse(QRectF(7, 7, 10, 10))
+            for x1, y1, x2, y2 in ((12, 2, 12, 4), (12, 20, 12, 22), (2, 12, 4, 12),
+                                    (20, 12, 22, 12), (5, 5, 6, 6), (18, 18, 19, 19),
+                                    (5, 19, 6, 18), (18, 6, 19, 5)):
+                painter.drawLine(x1, y1, x2, y2)
+        elif kind == "theme_dark":
+            path = QPainterPath(QPointF(11, 3))
+            path.cubicTo(1, 4, 1, 19, 12, 21)
+            path.cubicTo(17, 22, 21, 18, 21, 14)
+            path.cubicTo(10, 18, 6, 9, 11, 3)
+            painter.drawPath(path)
+        elif kind == "open":
+            painter.drawPolyline(QPolygonF([QPointF(3, 19), QPointF(3, 5), QPointF(9, 5),
+                                            QPointF(12, 8), QPointF(20, 8), QPointF(20, 10)]))
+            painter.drawPolygon(QPolygonF([QPointF(3, 19), QPointF(7, 11), QPointF(22, 11),
+                                           QPointF(18, 19)]))
+        elif kind == "export":
+            painter.drawPolyline(QPolygonF([QPointF(8, 16), QPointF(4, 16), QPointF(4, 3),
+                                            QPointF(14, 3), QPointF(18, 7), QPointF(18, 10)]))
+            painter.drawPolyline(QPolygonF([QPointF(14, 3), QPointF(14, 7), QPointF(18, 7)]))
+            painter.drawLine(13, 11, 13, 20)
+            painter.drawPolyline(QPolygonF([QPointF(9, 16), QPointF(13, 20), QPointF(17, 16)]))
+            painter.drawPolyline(QPolygonF([QPointF(6, 20), QPointF(6, 22), QPointF(20, 22),
+                                            QPointF(20, 20)]))
+        elif kind == "split":
+            painter.drawRoundedRect(QRectF(2, 2, 8, 13), 1, 1)
+            painter.drawRoundedRect(QRectF(14, 9, 8, 13), 1, 1)
+            painter.drawLine(6, 19, 12, 19)
+            painter.drawPolyline(QPolygonF([QPointF(9, 16), QPointF(12, 19), QPointF(9, 22)]))
+        elif kind in ("zoom_in", "zoom_out"):
+            painter.drawEllipse(QRectF(3, 3, 13, 13))
+            painter.drawLine(15, 15, 21, 21)
+            painter.drawLine(6, 9, 13, 9)
+            if kind == "zoom_in":
+                painter.drawLine(9, 6, 9, 13)
+        painter.end()
+        icon.addPixmap(pixmap, mode)
+    return icon

repdf/packaging_smoke.py

@@ -0,0 +1,97 @@
+from __future__ import annotations
+
+import json
+import os
+import tempfile
+import traceback
+from pathlib import Path
+
+
+def main(report_path: str) -> int:
+    report = Path(report_path)
+    report.parent.mkdir(parents=True, exist_ok=True)
+    process = None
+    try:
+        os.environ["QT_QPA_PLATFORM"] = "offscreen"
+        from PySide6.QtGui import QImage
+        from PySide6.QtWidgets import QApplication
+        from pypdf import PdfReader, PdfWriter
+        from repdf import __version__
+        from repdf.app import load_app_icon
+        from repdf.core import DocumentSelection, export_selected_pages, export_documents, split_documents
+        from repdf.renderer import start_render_backend
+        from repdf.preferences import LanguageController
+        from repdf.strings import tr
+        from repdf.theme import ThemeController
+        app = QApplication([])
+        language = LanguageController("zh")
+        if language.qt_translator.isEmpty():
+            raise RuntimeError("Traditional Chinese dialog translations are missing")
+        language.set_mode("en")
+        if tr("第 {p0} 頁", p0=1) != "Page 1":
+            raise RuntimeError("English translation failed")
+        theme = ThemeController(app, "light")
+        theme.set_mode("dark")
+        language.close()
+        if load_app_icon().isNull():
+            raise RuntimeError("Application icon is missing")
+        with tempfile.TemporaryDirectory(prefix="repdf-smoke-") as directory:
+            root = Path(directory)
+            source = root / "source.pdf"
+            writer = PdfWriter()
+            for width in (200, 300):
+                writer.add_blank_page(width=width, height=400)
+            with source.open("wb") as stream:
+                writer.write(stream)
+            process = start_render_backend()
+            process.stdin.write(json.dumps({
+                "source": str(source), "output_dir": str(root),
+                "scale": 0.5, "generation": 1,
+            }) + "\n")
+            process.stdin.flush()
+            pages = []
+            for line in process.stdout:
+                message = json.loads(line)
+                if message["type"] == "error":
+                    raise RuntimeError(message["message"])
+                if message["type"] == "page":
+                    if QImage(message["path"]).isNull():
+                        raise RuntimeError("Invalid rendered page")
+                    pages.append(message["page"])
+                if message["type"] == "done":
+                    break
+            if pages != [0, 1]:
+                raise RuntimeError(f"Unexpected rendered pages: {pages}")
+            output = root / "reordered.pdf"
+            export_selected_pages(source, output, [1, 0])
+            if [int(page.mediabox.width) for page in PdfReader(output).pages] != [300, 200]:
+                raise RuntimeError("Reordered export failed")
+            second = root / "second.pdf"
+            writer = PdfWriter()
+            writer.add_blank_page(width=400, height=500)
+            with second.open("wb") as stream:
+                writer.write(stream)
+            selections = [DocumentSelection(second, (0,)), DocumentSelection(source, (1, 0))]
+            merged = root / "multi.pdf"
+            export_documents(selections, merged)
+            if [int(page.mediabox.width) for page in PdfReader(merged).pages] != [400, 300, 200]:
+                raise RuntimeError("Multi-document export failed")
+            single_pages = split_documents(selections, root / "single.pdf")
+            if [int(PdfReader(path).pages[0].mediabox.width) for path in single_pages] != [400, 300, 200]:
+                raise RuntimeError("Multi-document split failed")
+        report.write_text(json.dumps({"ok": True, "version": __version__}), encoding="utf-8")
+        return 0
+    except Exception:
+        report.write_text(json.dumps({"ok": False, "error": traceback.format_exc()}), encoding="utf-8")
+        return 1
+    finally:
+        if process is not None:
+            process.terminate()
+            try:
+                process.wait(timeout=5)
+            except Exception:
+                process.kill()
+                process.wait(timeout=5)
+            for stream in (process.stdin, process.stdout, process.stderr):
+                if stream is not None:
+                    stream.close()

repdf/preferences.py

@@ -0,0 +1,79 @@
+from importlib.resources import files
+
+from PySide6.QtCore import QLibraryInfo, QLocale, QObject, QTranslator, Signal
+from PySide6.QtWidgets import QApplication
+
+from repdf import strings
+
+
+def migrate_preferences(settings, legacy) -> None:
+    """Copy existing choices once without changing the old app's settings."""
+    modes = {"ui/language": {"system", "zh", "en"}, "ui/theme": {"system", "light", "dark"}}
+    for key, allowed in modes.items():
+        if not settings.contains(key):
+            value = legacy.value(key)
+            if value in allowed:
+                settings.setValue(key, value)
+
+
+def system_language() -> str:
+    locale = QLocale.system()
+    preferred = locale.uiLanguages()
+    if preferred:
+        language = preferred[0].lower().replace("_", "-").split("-")[0]
+        return "zh" if language == "zh" else "en"
+    return "zh" if locale.language() == QLocale.Language.Chinese else "en"
+
+
+class DialogTranslator(QTranslator):
+    def isEmpty(self):
+        return False
+
+    def translate(self, context, source, disambiguation=None, n=-1):
+        words = {"&Yes": "是(&Y)", "&No": "否(&N)", "Yes": "是", "No": "否",
+                 "OK": "確定", "&OK": "確定", "Cancel": "取消", "&Cancel": "取消",
+                 "Open": "開啟", "&Open": "開啟(&O)", "Save": "儲存", "&Save": "儲存(&S)",
+                 "Close": "關閉", "&Close": "關閉", "File &name:": "檔案名稱(&N)：",
+                 "Files of type:": "檔案類型：", "Look in:": "查詢位置：",
+                 "Save in:": "儲存位置：", "Name": "名稱", "Size": "大小", "Type": "類型",
+                 "Date Modified": "修改時間", "All Files (*)": "所有檔案 (*)"}
+        if source in words:
+            return words[source] if strings.LANGUAGE == "zh" else source
+        return None
+
+
+class LanguageController(QObject):
+    changed = Signal()
+
+    def __init__(self, mode="system", parent=None):
+        super().__init__(parent)
+        self.mode = mode if mode in {"system", "zh", "en"} else "system"
+        self.translator = DialogTranslator(self)
+        self.qt_translator = QTranslator(self)
+        if not self.qt_translator.load(str(files("repdf").joinpath("assets", "qtbase_zh_TW.qm"))):
+            self.qt_translator.load("qtbase_zh_TW", QLibraryInfo.path(QLibraryInfo.LibraryPath.TranslationsPath))
+        self.refresh()
+
+    @property
+    def language(self):
+        return strings.LANGUAGE
+
+    def set_mode(self, mode):
+        if mode not in {"system", "zh", "en"}:
+            raise ValueError(mode)
+        self.mode = mode
+        self.refresh()
+
+    def refresh(self):
+        strings.LANGUAGE = system_language() if self.mode == "system" else self.mode
+        app = QApplication.instance()
+        app.removeTranslator(self.translator)
+        app.removeTranslator(self.qt_translator)
+        if strings.LANGUAGE == "zh":
+            app.installTranslator(self.qt_translator)
+        app.installTranslator(self.translator)
+        self.changed.emit()
+
+    def close(self):
+        QApplication.instance().removeTranslator(self.translator)
+        QApplication.instance().removeTranslator(self.qt_translator)

repdf/render_worker.py

@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+import json
+import socket
+import sys
+from pathlib import Path
+from typing import TextIO
+
+import pypdfium2 as pdfium
+
+
+def render_document(
+    source: Path, scale: float, output_dir: Path, generation: int,
+    output_stream: TextIO | None = None,
+) -> None:
+    document = pdfium.PdfDocument(str(source))
+    try:
+        for page_index in range(len(document)):
+            page = document[page_index]
+            try:
+                bitmap = page.render(scale=max(scale, 0.1))
+                try:
+                    image = bitmap.to_pil().convert("RGB")
+                    output = output_dir / f"g{generation}-p{page_index}.png"
+                    image.save(output, "PNG")
+                finally:
+                    bitmap.close()
+            finally:
+                page.close()
+            print(json.dumps({
+                "type": "page", "generation": generation,
+                "page": page_index, "path": str(output),
+            }), file=output_stream, flush=True)
+    finally:
+        document.close()
+
+
+def serve(
+    input_stream: TextIO | None = None,
+    output_stream: TextIO | None = None,
+    token: str | None = None,
+) -> int:
+    input_stream = input_stream if input_stream is not None else sys.stdin
+    output_stream = output_stream if output_stream is not None else sys.stdout
+    ready = {"type": "ready"}
+    if token is not None:
+        ready["token"] = token
+    print(json.dumps(ready), file=output_stream, flush=True)
+    for line in input_stream:
+        request: dict[str, object] = {}
+        try:
+            request = json.loads(line)
+            render_document(
+                Path(request["source"]), float(request["scale"]),
+                Path(request["output_dir"]), int(request["generation"]), output_stream,
+            )
+            print(json.dumps({
+                "type": "done", "generation": int(request["generation"]),
+            }), file=output_stream, flush=True)
+        except Exception as exc:
+            print(json.dumps({
+                "type": "error",
+                "generation": request.get("generation", -1) if isinstance(request, dict) else -1,
+                "message": str(exc),
+            }), file=output_stream, flush=True)
+    return 0
+
+
+def serve_socket(port: int, token: str) -> int:
+    with socket.create_connection(("127.0.0.1", port), timeout=30) as connection:
+        connection.settimeout(None)
+        with connection.makefile("r", encoding="utf-8") as reader:
+            with connection.makefile("w", encoding="utf-8") as writer:
+                return serve(reader, writer, token)
+
+
+def main() -> int:
+    if len(sys.argv) == 2 and sys.argv[1] == "--server":
+        return serve()
+    if len(sys.argv) != 5:
+        print("invalid render worker arguments", file=sys.stderr)
+        return 2
+    try:
+        render_document(
+            Path(sys.argv[1]), float(sys.argv[2]), Path(sys.argv[3]), int(sys.argv[4])
+        )
+        return 0
+    except Exception as exc:
+        print(str(exc), file=sys.stderr, flush=True)
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())