shellscripts 0.23.1__py3-none-any.whl

shell_scripts/commands/pdf_split_by_format.py

@@ -0,0 +1,243 @@
+#!/usr/bin/env python3
+import os
+import re
+import subprocess
+import tempfile
+
+from shell_scripts.utils import require_commands, print_error
+
+PROGRAM = "shellscripts"
+DESCRIPTION = "Split PDF into parts by page format changes."
+
+
+def print_help(version):
+    print(
+        f"Usage: {PROGRAM} pdf-split-by-format <file1.pdf> [file2.pdf ...] ({version})"
+    )
+    print()
+    print("pdf-split-by-format options:")
+    print("  <files...>  - Input PDF files to split.")
+    print("  --help      - Show this help message.")
+
+
+def _get_page_formats(pdf, total_pages):
+    r = subprocess.run(
+        ["pdfinfo", "-f", "1", "-l", str(total_pages), pdf],
+        capture_output=True,
+        text=True,
+        stderr=subprocess.DEVNULL,
+    )
+    formats = []
+    for line in r.stdout.splitlines():
+        if re.search(r"Page\s+.*size:", line):
+            fmt = re.sub(r"Page\s+\d+\s+size:\s*", "", line).strip()
+            formats.append(fmt)
+    return formats
+
+
+def _get_total_pages(pdf):
+    r = subprocess.run(
+        ["pdfinfo", pdf],
+        capture_output=True,
+        text=True,
+        stderr=subprocess.DEVNULL,
+    )
+    for line in r.stdout.splitlines():
+        if line.startswith("Pages:"):
+            return int(line.split(":")[1].strip())
+    return None
+
+
+def _has_toc(pdf):
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=True) as tmp:
+            tmp_path = tmp.name
+        subprocess.run(
+            ["qpdf", "--object-streams=disable", pdf, tmp_path],
+            capture_output=True,
+        )
+        r = subprocess.run(
+            ["pdftk", tmp_path, "dump_data"],
+            capture_output=True,
+            text=True,
+        )
+        os.unlink(tmp_path)
+        return "BookmarkBegin" in r.stdout
+    except Exception:
+        return False
+
+
+def _extract_toc_for_range(data_file, start, end):
+    entries = []
+    with open(data_file) as f:
+        content = f.read()
+
+    level = title = page = ""
+    for line in content.splitlines():
+        if line == "BookmarkBegin":
+            if level and page:
+                p = int(page)
+                if start <= p <= end:
+                    entries.append((level, title, str(p - start + 1)))
+            level = title = page = ""
+        elif line.startswith("BookmarkTitle: "):
+            title = line[15:]
+        elif line.startswith("BookmarkLevel: "):
+            level = line.split()[1]
+        elif line.startswith("BookmarkPageNumber: "):
+            page = line.split()[1]
+    if level and page:
+        p = int(page)
+        if start <= p <= end:
+            entries.append((level, title, str(p - start + 1)))
+
+    result = []
+    for lv, ti, pg in entries:
+        result.append("BookmarkBegin")
+        if ti:
+            result.append(f"BookmarkTitle: {ti}")
+        if lv:
+            result.append(f"BookmarkLevel: {lv}")
+        result.append(f"BookmarkPageNumber: {pg}")
+    return "\n".join(result)
+
+
+def _apply_toc(output_file, toc_content):
+    if not toc_content.strip():
+        return
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".info", delete=False) as f:
+        f.write(toc_content)
+        info_file = f.name
+    try:
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as stripped_f:
+            stripped = stripped_f.name
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as toc_f:
+            with_toc = toc_f.name
+
+        r1 = subprocess.run(
+            ["qpdf", "--empty", "--pages", output_file, "1-z", "--", stripped],
+            capture_output=True,
+        )
+        if r1.returncode == 0:
+            r2 = subprocess.run(
+                ["pdftk", stripped, "update_info", info_file, "output", with_toc],
+                capture_output=True,
+            )
+            if r2.returncode == 0:
+                os.replace(with_toc, output_file)
+            else:
+                os.unlink(with_toc)
+                print(f"   [!] Warning: unable to update TOC for '{output_file}'.")
+        os.unlink(stripped)
+    except Exception:
+        pass
+    finally:
+        os.unlink(info_file)
+
+
+def run(args):
+    if not args:
+        print_error("No PDF files specified.")
+        print_help("")
+        return 1
+
+    require_commands("qpdf", "pdfinfo", "pdftk")
+
+    for input_pdf in args:
+        print("=" * 50)
+
+        if not os.path.isfile(input_pdf):
+            print(f"Warning: File '{input_pdf}' does not exist. Skipping...")
+            continue
+
+        print(f"Processing: {input_pdf}")
+        basename = os.path.splitext(os.path.basename(input_pdf))[0]
+
+        total_pages = _get_total_pages(input_pdf)
+        if total_pages is None:
+            print(f"Error: Cannot read pages from '{input_pdf}'. Skipping...")
+            continue
+
+        print(f"Analyzing {total_pages} pages...")
+        formats = _get_page_formats(input_pdf, total_pages)
+
+        unique = set(formats)
+        if len(unique) <= 1:
+            print(
+                f"-> INFO: All pages have the same format: [{formats[0] if formats else 'unknown'}]."
+            )
+            print("-> No splitting needed. Moving to next...")
+            continue
+
+        has_toc = _has_toc(input_pdf)
+        data_file = None
+        if has_toc:
+            with tempfile.NamedTemporaryFile(suffix=".pdf", delete=False) as tmp:
+                tmp_pdf = tmp.name
+            subprocess.run(
+                ["qpdf", "--object-streams=disable", input_pdf, tmp_pdf],
+                capture_output=True,
+            )
+            data_file = tempfile.mktemp()
+            subprocess.run(
+                ["pdftk", tmp_pdf, "dump_data", "output", data_file],
+                capture_output=True,
+            )
+            os.unlink(tmp_pdf)
+
+        start_page = 1
+        chunk_num = 1
+        prev_format = formats[0]
+
+        for i in range(1, total_pages):
+            current_format = formats[i]
+            if current_format != prev_format:
+                end_page = i
+                out_name = f"{basename}_{chunk_num:02d}.pdf"
+                print(
+                    f"-> Generating: {out_name} (Pages {start_page} - {end_page}) [Format: {prev_format}]"
+                )
+                subprocess.run(
+                    [
+                        "qpdf",
+                        input_pdf,
+                        "--pages",
+                        ".",
+                        f"{start_page}-{end_page}",
+                        "--",
+                        out_name,
+                    ],
+                )
+                if has_toc and data_file:
+                    toc = _extract_toc_for_range(data_file, start_page, end_page)
+                    _apply_toc(out_name, toc)
+
+                start_page = i + 1
+                prev_format = current_format
+                chunk_num += 1
+
+        out_name = f"{basename}_{chunk_num:02d}.pdf"
+        print(
+            f"-> Generating: {out_name} (Pages {start_page} - {total_pages}) [Format: {prev_format}]"
+        )
+        subprocess.run(
+            [
+                "qpdf",
+                input_pdf,
+                "--pages",
+                ".",
+                f"{start_page}-{total_pages}",
+                "--",
+                out_name,
+            ],
+        )
+        if has_toc and data_file:
+            toc = _extract_toc_for_range(data_file, start_page, total_pages)
+            _apply_toc(out_name, toc)
+            os.unlink(data_file)
+
+        print(f"-> Splitting of '{input_pdf}' complete: generated {chunk_num} files.")
+
+    print("=" * 50)
+    print("Batch processing completed successfully!")
+    return 0

shell_scripts/commands/pdf_split_by_toc.py

@@ -0,0 +1,197 @@
+#!/usr/bin/env python3
+import os
+import re
+import subprocess
+import tempfile
+
+from shell_scripts.utils import require_commands, print_error
+
+PROGRAM = "shellscripts"
+DESCRIPTION = "Split PDF into chapters by TOC level-1 entries."
+
+
+def print_help(version):
+    print(f"Usage: {PROGRAM} pdf-split-by-toc <document.pdf> ({version})")
+    print()
+    print("pdf-split-by-toc options:")
+    print("  <document.pdf>  - Input PDF file (required).")
+    print("  --help          - Show this help message.")
+
+
+def _parse_level1_toc(dump_content):
+    entries = []
+    level = title = page = ""
+    for line in dump_content.splitlines():
+        if line == "BookmarkBegin":
+            if level == "1" and page:
+                entries.append((int(page), title))
+            level = title = page = ""
+        elif line.startswith("BookmarkTitle: "):
+            title = line[15:]
+        elif line.startswith("BookmarkLevel: "):
+            level = line.split()[1]
+        elif line.startswith("BookmarkPageNumber: "):
+            page = line.split()[1]
+    if level == "1" and page:
+        entries.append((int(page), title))
+    return entries
+
+
+def _extract_toc_for_range(dump_content, start, end):
+    lines = []
+    level = title = page = ""
+    for line in dump_content.splitlines():
+        if line == "BookmarkBegin":
+            if level and page:
+                p = int(page)
+                if start <= p <= end:
+                    lines.append("BookmarkBegin")
+                    if title:
+                        lines.append(f"BookmarkTitle: {title}")
+                    if level:
+                        lines.append(f"BookmarkLevel: {level}")
+                    lines.append(f"BookmarkPageNumber: {p - start + 1}")
+            level = title = page = ""
+        elif line.startswith("BookmarkTitle: "):
+            title = line[15:]
+        elif line.startswith("BookmarkLevel: "):
+            level = line.split()[1]
+        elif line.startswith("BookmarkPageNumber: "):
+            page = line.split()[1]
+    if level and page:
+        p = int(page)
+        if start <= p <= end:
+            lines.append("BookmarkBegin")
+            if title:
+                lines.append(f"BookmarkTitle: {title}")
+            if level:
+                lines.append(f"BookmarkLevel: {level}")
+            lines.append(f"BookmarkPageNumber: {p - start + 1}")
+    return "\n".join(lines)
+
+
+def _sanitize_title(title):
+    safe = re.sub(r"[^A-Za-z0-9]", "-", title)
+    safe = re.sub(r"-+", "-", safe)
+    return safe.strip("-")
+
+
+def _apply_toc_to_file(output_file, toc_content):
+    if not toc_content.strip():
+        return
+    with tempfile.NamedTemporaryFile(mode="w", suffix=".info", delete=False) as f:
+        f.write(toc_content)
+        info_file = f.name
+    try:
+        stripped = tempfile.mktemp(suffix=".pdf")
+        with_toc = tempfile.mktemp(suffix=".pdf")
+        r1 = subprocess.run(
+            ["qpdf", "--empty", "--pages", output_file, "1-z", "--", stripped],
+            capture_output=True,
+        )
+        if r1.returncode == 0:
+            r2 = subprocess.run(
+                ["pdftk", stripped, "update_info", info_file, "output", with_toc],
+                capture_output=True,
+            )
+            if r2.returncode == 0:
+                os.replace(with_toc, output_file)
+            else:
+                if os.path.exists(with_toc):
+                    os.unlink(with_toc)
+                print(f"   [!] Warning: unable to update TOC for '{output_file}'.")
+        if os.path.exists(stripped):
+            os.unlink(stripped)
+    finally:
+        os.unlink(info_file)
+
+
+def run(args):
+    if not args or args[0].startswith("-"):
+        print_error("Input PDF file required.")
+        print_help("")
+        return 1
+
+    require_commands("pdftk", "qpdf")
+
+    input_file = args[0]
+    if not os.path.isfile(input_file):
+        print_error(f"File not found: {input_file}")
+        return 1
+
+    basename = os.path.splitext(os.path.basename(input_file))[0]
+
+    with tempfile.TemporaryDirectory() as tmp_dir:
+        tmp_pdf = os.path.join(tmp_dir, "prepared.pdf")
+        data_file = os.path.join(tmp_dir, "data.txt")
+
+        print("Preparing document (disabling Object Streams for TOC reading)...")
+        r = subprocess.run(
+            ["qpdf", "--object-streams=disable", input_file, tmp_pdf],
+            capture_output=True,
+        )
+        if r.returncode != 0:
+            print_error("Error during initial processing with qpdf.")
+            return 1
+
+        print("Extracting TOC data...")
+        subprocess.run(
+            ["pdftk", tmp_pdf, "dump_data", "output", data_file],
+            capture_output=True,
+        )
+
+        with open(data_file) as f:
+            dump_content = f.read()
+
+        if "BookmarkBegin" not in dump_content:
+            print_error("No TOC found even after decompression.")
+            print("The PDF may use 'Named Destinations' instead of explicit page numbers.")
+            return 1
+
+        total_pages = None
+        for line in dump_content.splitlines():
+            if line.startswith("NumberOfPages:"):
+                total_pages = int(line.split()[1])
+                break
+
+        if total_pages is None:
+            print_error("Cannot read total pages.")
+            return 1
+
+        print(f"Document has {total_pages} total pages.")
+
+        toc_entries = _parse_level1_toc(dump_content)
+        if not toc_entries:
+            print_error("TOC found, but no valid level-1 entries with explicit pages.")
+            return 1
+
+        num_sections = len(toc_entries)
+        print(f"Found {num_sections} level-1 chapters. Starting split...")
+
+        for i, (start_page, title) in enumerate(toc_entries):
+            if i + 1 < num_sections:
+                next_page = toc_entries[i + 1][0]
+                end_page = max(next_page - 1, start_page)
+            else:
+                end_page = total_pages
+
+            safe_title = _sanitize_title(title)
+            index_padded = f"{i + 1:02d}"
+            output_name = f"{basename}_{index_padded}_{safe_title}.pdf"
+
+            print(f"-> Creating: {output_name} (Pages {start_page} - {end_page})")
+
+            r = subprocess.run(
+                ["qpdf", input_file, "--pages", input_file,
+                 f"{start_page}-{end_page}", "--", output_name],
+            )
+            if r.returncode != 0:
+                print(f"   [!] Error extracting section '{title}'")
+                continue
+
+            toc_content = _extract_toc_for_range(dump_content, start_page, end_page)
+            _apply_toc_to_file(output_name, toc_content)
+
+    print("---")
+    print("Split completed successfully!")
+    return 0

shell_scripts/commands/pdf_tiler_090.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+import subprocess
+from pathlib import Path
+
+from shell_scripts.utils import require_commands, print_error
+
+PROGRAM = "shellscripts"
+DESCRIPTION = "Tile PDF to A4 pages at 90% scale using plakativ."
+
+
+def print_help(version):
+    print(f"Usage: {PROGRAM} pdf-tiler-090 <input.pdf> ({version})")
+    print()
+    print("pdf-tiler-090 options:")
+    print("  <input.pdf>  - Input PDF file (required).")
+    print("  --help       - Show this help message.")
+    print()
+    print("Outputs <basename>_tiled-A4.pdf in the same directory as the input.")
+
+
+def run(args):
+    """@brief Execute `pdf-tiler-090` command with blocking subprocess launch.
+
+    @details Validates input argument and file presence, builds `plakativ`
+    command vector with fixed A4/0.90 parameters, then executes it via
+    `subprocess.run` while inheriting stdio streams.
+    @param args {list[str]} Command arguments excluding command token.
+    @return {int} `1` on validation failure; child process return code otherwise.
+    @satisfies REQ-029, REQ-055, REQ-056, REQ-064
+    """
+
+    if not args or args[0].startswith("-"):
+        print_error("Input PDF file required.")
+        print_help("")
+        return 1
+
+    require_commands("plakativ")
+
+    input_file = Path(args[0])
+    if not input_file.is_file():
+        print_error(f"File not found: {input_file}")
+        return 1
+
+    output_file = input_file.parent / f"{input_file.stem}_tiled-A4.pdf"
+
+    cmd = [
+        "plakativ",
+        "--factor",
+        "0.90",
+        "--pagesize",
+        "A4",
+        "--border",
+        "5mm",
+        "--cutting-guides",
+        "-o",
+        str(output_file),
+        str(input_file),
+    ]
+    require_commands(cmd[0])
+    result = subprocess.run(cmd)
+    return result.returncode

shell_scripts/commands/pdf_tiler_100.py

@@ -0,0 +1,61 @@
+#!/usr/bin/env python3
+import subprocess
+from pathlib import Path
+
+from shell_scripts.utils import require_commands, print_error
+
+PROGRAM = "shellscripts"
+DESCRIPTION = "Tile PDF to A4 pages at original A1 size using plakativ."
+
+
+def print_help(version):
+    print(f"Usage: {PROGRAM} pdf-tiler-100 <input.pdf> ({version})")
+    print()
+    print("pdf-tiler-100 options:")
+    print("  <input.pdf>  - Input PDF file (required).")
+    print("  --help       - Show this help message.")
+    print()
+    print("Outputs <basename>_tiled-A4.pdf in the same directory as the input.")
+
+
+def run(args):
+    """@brief Execute `pdf-tiler-100` command with blocking subprocess launch.
+
+    @details Validates input argument and file presence, builds `plakativ`
+    command vector with fixed A1 source size and A4 tiling parameters, then
+    executes it via `subprocess.run` while inheriting stdio streams.
+    @param args {list[str]} Command arguments excluding command token.
+    @return {int} `1` on validation failure; child process return code otherwise.
+    @satisfies REQ-029, REQ-055, REQ-056, REQ-064
+    """
+
+    if not args or args[0].startswith("-"):
+        print_error("Input PDF file required.")
+        print_help("")
+        return 1
+
+    require_commands("plakativ")
+
+    input_file = Path(args[0])
+    if not input_file.is_file():
+        print_error(f"File not found: {input_file}")
+        return 1
+
+    output_file = input_file.parent / f"{input_file.stem}_tiled-A4.pdf"
+
+    cmd = [
+        "plakativ",
+        "--size",
+        "A1",
+        "--pagesize",
+        "A4",
+        "--border",
+        "5mm",
+        "--cutting-guides",
+        "-o",
+        str(output_file),
+        str(input_file),
+    ]
+    require_commands(cmd[0])
+    result = subprocess.run(cmd)
+    return result.returncode