dforge-cli 1.0.1__py3-none-any.whl

dforge/loading.py

@@ -0,0 +1,19 @@
+from rich.console import Console
+from rich.status import Status
+
+console = Console()
+
+
+class Loader:
+    def __init__(self, text):
+        self.status = Status(
+            f"[bold cyan]{text}[/bold cyan]",
+            spinner="dots"
+        )
+
+    def __enter__(self):
+        self.status.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        self.status.stop()

dforge/menu.py

@@ -0,0 +1,115 @@
+import questionary
+
+
+def show_menu(title: str, choices: list[str]):
+    return questionary.select(
+        title,
+        choices=choices,
+    ).ask()
+
+
+def main_menu():
+    return show_menu(
+        "What would you like to do?",
+        [
+            "📄 PDF Tools",
+            "🔍 OCR",
+            "🔄 Conversion",
+            "🖼 Image Processing",
+            "⚡ Batch Processing",
+            "👀 Watch Folder",
+            "⚙ Settings",
+            "❌ Exit",
+        ],
+    )
+
+
+def pdf_menu():
+    return show_menu(
+        "PDF Tools",
+        [
+            "Merge PDFs",
+            "Split PDF",
+            "Compress PDF",
+            "Rotate PDF",
+            "Extract Pages",
+            "Watermark PDF",
+            "Encrypt PDF",
+            "Decrypt PDF",
+            "⬅ Back",
+        ],
+    )
+def ocr_menu():
+    return show_menu(
+        "OCR Tools",
+        [
+            "OCR Image/PDF",
+            "Searchable PDF",
+            "Batch OCR",
+            "OCR Folder",
+            "Extract Tables",
+            "OCR Settings",
+            "⬅ Back",
+        ],
+    )
+def conversion_menu():
+    return show_menu(
+        "Conversion Tools",
+        [
+            "Markdown → PDF",
+            "Markdown → DOCX",
+            "DOCX → PDF",
+            "DOCX → Markdown",
+            "Images → PDF",
+            "PDF → Images",
+            "⬅ Back",
+        ],
+    )
+def extract_menu():
+    return show_menu(
+        "Extract Tools",
+        [
+            "Extract Text",
+            "Extract Images",
+            "Extract Metadata",
+            "⬅ Back",
+        ],
+    )
+
+
+def batch_menu():
+    return show_menu(
+        "Batch Tools",
+        [
+            "Batch Convert",
+            "Batch Compress",
+            "Batch OCR",
+            "⬅ Back",
+        ],
+    )
+
+
+def automation_menu():
+    return show_menu(
+        "Automation Tools",
+        [
+            "Watch Folder",
+            "Auto OCR",
+            "Auto Convert",
+            "Scheduled Tasks",
+            "⬅ Back",
+        ],
+    )
+
+
+def image_menu():
+    return show_menu(
+        "Image Tools",
+        [
+            "Resize Images",
+            "Convert Format",
+            "Crop Images",
+            "Watermark Images",
+            "⬅ Back",
+        ],
+    )

dforge/operations.py

@@ -0,0 +1,314 @@
+"""
+DForge PDF Operations
+Handles: merge, split, compress, rotate, page extraction, watermark, encrypt, decrypt
+"""
+
+from __future__ import annotations
+
+import os
+import subprocess
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from rich.progress import Progress, SpinnerColumn, TextColumn
+
+from dforge.utils import (
+    abort, console, ensure_parent, ghostscript_bin,
+    info, require_ghostscript, resolve_output, success, warn,
+)
+from dforge.config import DEFAULT_COMPRESS_PRESET
+
+
+# ---------------------------------------------------------------------------
+# Merge
+# ---------------------------------------------------------------------------
+
+def merge(inputs: List[Path], output: Path) -> None:
+    """Merge multiple PDF files into one."""
+    try:
+        from pypdf import PdfWriter
+    except ImportError:
+        abort("pypdf is required. Run: pip install pypdf")
+
+    for f in inputs:
+        if not f.exists():
+            abort(f"File not found: {f}")
+
+    writer = PdfWriter()
+    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console) as progress:
+        task = progress.add_task("Merging PDFs...", total=len(inputs))
+        for f in inputs:
+            from pypdf import PdfReader
+            reader = PdfReader(str(f))
+            for page in reader.pages:
+                writer.add_page(page)
+            progress.advance(task)
+
+    ensure_parent(output)
+    with open(output, "wb") as fh:
+        writer.write(fh)
+    success(f"Merged {len(inputs)} files -> [bold]{output}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Split
+# ---------------------------------------------------------------------------
+
+def split(input_path: Path, output_dir: Optional[Path] = None) -> None:
+    """Split a PDF into individual pages."""
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        abort("pypdf is required. Run: pip install pypdf")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    dest = output_dir or input_path.parent / (input_path.stem + "_pages")
+    dest.mkdir(parents=True, exist_ok=True)
+
+    reader = PdfReader(str(input_path))
+    total = len(reader.pages)
+
+    with Progress(SpinnerColumn(), TextColumn("[progress.description]{task.description}"), console=console) as progress:
+        task = progress.add_task(f"Splitting {total} pages...", total=total)
+        for i, page in enumerate(reader.pages, start=1):
+            writer = PdfWriter()
+            writer.add_page(page)
+            out_file = dest / f"{input_path.stem}_page_{i:04d}.pdf"
+            with open(out_file, "wb") as fh:
+                writer.write(fh)
+            progress.advance(task)
+
+    success(f"Split into {total} pages -> [bold]{dest}/[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Compress
+# ---------------------------------------------------------------------------
+
+def compress(input_path: Path, output: Optional[Path] = None, preset: str = DEFAULT_COMPRESS_PRESET) -> None:
+    """Compress a PDF using Ghostscript."""
+    require_ghostscript()
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    out = output or resolve_output(input_path, None, "_compressed", ".pdf")
+    ensure_parent(out)
+
+    gs = ghostscript_bin()
+    cmd = [
+        gs,
+        "-sDEVICE=pdfwrite",
+        "-dCompatibilityLevel=1.4",
+        f"-dPDFSETTINGS=/{preset}",
+        "-dNOPAUSE",
+        "-dQUIET",
+        "-dBATCH",
+        f"-sOutputFile={out}",
+        str(input_path),
+    ]
+
+    info(f"Compressing with preset '[bold]{preset}[/bold]'...")
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    if result.returncode != 0:
+        abort(f"Ghostscript error:\n{result.stderr}")
+
+    original_kb = input_path.stat().st_size / 1024
+    compressed_kb = out.stat().st_size / 1024
+    ratio = (1 - compressed_kb / original_kb) * 100 if original_kb > 0 else 0
+    success(
+        f"Compressed: {original_kb:.1f} KB -> {compressed_kb:.1f} KB "
+        f"([green]{ratio:.1f}% reduction[/green]) -> [bold]{out}[/bold]"
+    )
+
+
+# ---------------------------------------------------------------------------
+# Rotate
+# ---------------------------------------------------------------------------
+
+def rotate(input_path: Path, degrees: int, output: Optional[Path] = None) -> None:
+    """Rotate all pages of a PDF by the given degrees (90, 180, 270)."""
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        abort("pypdf is required.")
+
+    if degrees not in (90, 180, 270):
+        abort("Rotation must be 90, 180, or 270 degrees.")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    reader = PdfReader(str(input_path))
+    writer = PdfWriter()
+
+    for page in reader.pages:
+        page.rotate(degrees)
+        writer.add_page(page)
+
+    out = output or resolve_output(input_path, None, f"_rotated{degrees}", ".pdf")
+    ensure_parent(out)
+    with open(out, "wb") as fh:
+        writer.write(fh)
+    success(f"Rotated {len(reader.pages)} pages by {degrees} deg -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Extract page range
+# ---------------------------------------------------------------------------
+
+def extract_pages(input_path: Path, page_range: str, output: Optional[Path] = None) -> None:
+    """
+    Extract a page range from a PDF.
+    page_range format: "1-5" or "3" or "2,4,6"
+    """
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        abort("pypdf is required.")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    reader = PdfReader(str(input_path))
+    total = len(reader.pages)
+
+    # Parse range
+    pages: List[int] = []
+    for part in page_range.split(","):
+        part = part.strip()
+        if "-" in part:
+            start_s, end_s = part.split("-", 1)
+            start, end = int(start_s), int(end_s)
+            pages.extend(range(start, end + 1))
+        else:
+            pages.append(int(part))
+
+    # Validate
+    invalid = [p for p in pages if p < 1 or p > total]
+    if invalid:
+        abort(f"Page(s) out of range (document has {total} pages): {invalid}")
+
+    writer = PdfWriter()
+    for p in pages:
+        writer.add_page(reader.pages[p - 1])
+
+    out = output or resolve_output(input_path, None, f"_pages_{page_range.replace(',', '-')}", ".pdf")
+    ensure_parent(out)
+    with open(out, "wb") as fh:
+        writer.write(fh)
+    success(f"Extracted {len(pages)} pages -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Watermark
+# ---------------------------------------------------------------------------
+
+def watermark(input_path: Path, watermark_file: Path, output: Optional[Path] = None) -> None:
+    """Overlay a watermark (PDF or image) on every page."""
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        abort("pypdf is required.")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+    if not watermark_file.exists():
+        abort(f"Watermark file not found: {watermark_file}")
+
+    # If watermark is an image, convert it to a single-page PDF first
+    wm_path = watermark_file
+    if watermark_file.suffix.lower() in {".png", ".jpg", ".jpeg", ".tiff", ".bmp"}:
+        wm_path = _image_to_pdf_watermark(watermark_file)
+
+    wm_reader = PdfReader(str(wm_path))
+    wm_page = wm_reader.pages[0]
+
+    reader = PdfReader(str(input_path))
+    writer = PdfWriter()
+
+    for page in reader.pages:
+        page.merge_page(wm_page)
+        writer.add_page(page)
+
+    out = output or resolve_output(input_path, None, "_watermarked", ".pdf")
+    ensure_parent(out)
+    with open(out, "wb") as fh:
+        writer.write(fh)
+    success(f"Watermarked {len(reader.pages)} pages -> [bold]{out}[/bold]")
+
+
+def _image_to_pdf_watermark(image_path: Path) -> Path:
+    """Convert an image file to a temporary single-page PDF for use as a watermark."""
+    import tempfile
+    try:
+        import img2pdf
+        from PIL import Image
+    except ImportError:
+        abort("img2pdf and Pillow are required for image watermarks.")
+
+    tmp = Path(tempfile.mktemp(suffix=".pdf"))
+    with open(tmp, "wb") as fh:
+        fh.write(img2pdf.convert(str(image_path)))
+    return tmp
+
+
+# ---------------------------------------------------------------------------
+# Encrypt
+# ---------------------------------------------------------------------------
+
+def encrypt(input_path: Path, password: str, output: Optional[Path] = None) -> None:
+    """Encrypt a PDF with a password."""
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        abort("pypdf is required.")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    reader = PdfReader(str(input_path))
+    writer = PdfWriter()
+    for page in reader.pages:
+        writer.add_page(page)
+
+    writer.encrypt(password)
+
+    out = output or resolve_output(input_path, None, "_encrypted", ".pdf")
+    ensure_parent(out)
+    with open(out, "wb") as fh:
+        writer.write(fh)
+    success(f"Encrypted -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Decrypt
+# ---------------------------------------------------------------------------
+
+def decrypt(input_path: Path, password: str, output: Optional[Path] = None) -> None:
+    """Decrypt a password-protected PDF."""
+    try:
+        from pypdf import PdfReader, PdfWriter
+    except ImportError:
+        abort("pypdf is required.")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    reader = PdfReader(str(input_path))
+    if reader.is_encrypted:
+        if not reader.decrypt(password):
+            abort("Incorrect password or unsupported encryption.")
+
+    writer = PdfWriter()
+    for page in reader.pages:
+        writer.add_page(page)
+
+    out = output or resolve_output(input_path, None, "_decrypted", ".pdf")
+    ensure_parent(out)
+    with open(out, "wb") as fh:
+        writer.write(fh)
+    success(f"Decrypted -> [bold]{out}[/bold]")

dforge/processor.py

@@ -0,0 +1,251 @@
+"""
+DForge Image Processing Module
+Handles: enhance, deskew, denoise, resize, and the full OCR preprocessing pipeline
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Optional, Tuple
+
+from dforge.utils import abort, info, success, warn
+from dforge.config import DEFAULT_COMPRESS_QUALITY
+
+
+# ---------------------------------------------------------------------------
+# Internal helpers
+# ---------------------------------------------------------------------------
+
+def _load_pil(path: Path):
+    """Load an image using Pillow, aborting on failure."""
+    try:
+        from PIL import Image
+    except ImportError:
+        abort("Pillow is required. Run: pip install Pillow")
+
+    if not path.exists():
+        abort(f"File not found: {path}")
+    return Image.open(str(path))
+
+
+def _load_cv2(path: Path):
+    """Load an image using OpenCV."""
+    try:
+        import cv2
+        import numpy as np
+    except ImportError:
+        abort("opencv-python-headless is required. Run: pip install opencv-python-headless")
+
+    img = cv2.imread(str(path))
+    if img is None:
+        abort(f"Could not read image: {path}")
+    return img
+
+
+def _save_pil(img, output: Path, quality: int = DEFAULT_COMPRESS_QUALITY) -> None:
+    kwargs = {}
+    if output.suffix.lower() in {".jpg", ".jpeg"}:
+        kwargs["quality"] = quality
+    img.save(str(output), **kwargs)
+
+
+# ---------------------------------------------------------------------------
+# Enhance
+# ---------------------------------------------------------------------------
+
+def enhance(input_path: Path, output: Optional[Path] = None) -> None:
+    """
+    Enhance an image for better readability.
+    Applies: auto-contrast, sharpness boost.
+    """
+    try:
+        from PIL import Image, ImageEnhance, ImageOps
+    except ImportError:
+        abort("Pillow is required.")
+
+    img = _load_pil(input_path)
+
+    # Convert to RGB if needed
+    if img.mode not in ("RGB", "L"):
+        img = img.convert("RGB")
+
+    img = ImageOps.autocontrast(img, cutoff=1)
+    sharpener = ImageEnhance.Sharpness(img)
+    img = sharpener.enhance(1.5)
+    contrast = ImageEnhance.Contrast(img)
+    img = contrast.enhance(1.3)
+
+    out = output or input_path.with_name(input_path.stem + "_enhanced" + input_path.suffix)
+    _save_pil(img, out)
+    success(f"Enhanced -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Deskew
+# ---------------------------------------------------------------------------
+
+def deskew(input_path: Path, output: Optional[Path] = None) -> None:
+    """
+    Detect and correct the skew angle of a scanned document image.
+    Uses OpenCV Hough line detection.
+    """
+    try:
+        import cv2
+        import numpy as np
+    except ImportError:
+        abort("opencv-python-headless is required.")
+
+    img = _load_cv2(input_path)
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if len(img.shape) == 3 else img
+    gray = cv2.bitwise_not(gray)
+    thresh = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
+
+    coords = np.column_stack(np.where(thresh > 0))
+    if len(coords) == 0:
+        warn("Could not detect text regions for deskewing.")
+        return
+
+    angle = cv2.minAreaRect(coords)[-1]
+    if angle < -45:
+        angle = 90 + angle
+
+    (h, w) = img.shape[:2]
+    center = (w // 2, h // 2)
+    M = cv2.getRotationMatrix2D(center, angle, 1.0)
+    rotated = cv2.warpAffine(img, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
+
+    out = output or input_path.with_name(input_path.stem + "_deskewed" + input_path.suffix)
+    cv2.imwrite(str(out), rotated)
+    success(f"Deskewed (corrected {angle:.2f} deg) -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Denoise
+# ---------------------------------------------------------------------------
+
+def denoise(input_path: Path, output: Optional[Path] = None) -> None:
+    """Remove noise from an image using OpenCV Non-Local Means."""
+    try:
+        import cv2
+    except ImportError:
+        abort("opencv-python-headless is required.")
+
+    img = _load_cv2(input_path)
+
+    if len(img.shape) == 2:  # grayscale
+        denoised = cv2.fastNlMeansDenoising(img, h=10, templateWindowSize=7, searchWindowSize=21)
+    else:
+        denoised = cv2.fastNlMeansDenoisingColored(img, h=10, hColor=10, templateWindowSize=7, searchWindowSize=21)
+
+    out = output or input_path.with_name(input_path.stem + "_denoised" + input_path.suffix)
+    cv2.imwrite(str(out), denoised)
+    success(f"Denoised -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# Resize
+# ---------------------------------------------------------------------------
+
+def resize(
+    input_path: Path,
+    width: Optional[int] = None,
+    height: Optional[int] = None,
+    scale: Optional[float] = None,
+    output: Optional[Path] = None,
+) -> None:
+    """
+    Resize an image.
+
+    Provide either (width, height), one of them (maintains aspect ratio), or a scale factor.
+    """
+    try:
+        from PIL import Image
+    except ImportError:
+        abort("Pillow is required.")
+
+    if width is None and height is None and scale is None:
+        abort("Provide --width, --height, or --scale.")
+
+    img = _load_pil(input_path)
+    orig_w, orig_h = img.size
+
+    if scale is not None:
+        new_w = int(orig_w * scale)
+        new_h = int(orig_h * scale)
+    elif width and height:
+        new_w, new_h = width, height
+    elif width:
+        new_w = width
+        new_h = int(orig_h * (width / orig_w))
+    else:
+        new_h = height
+        new_w = int(orig_w * (height / orig_h))
+
+    resized = img.resize((new_w, new_h), Image.LANCZOS)
+    out = output or input_path.with_name(input_path.stem + f"_{new_w}x{new_h}" + input_path.suffix)
+    _save_pil(resized, out)
+    success(f"Resized {orig_w}x{orig_h} -> {new_w}x{new_h} -> [bold]{out}[/bold]")
+
+
+# ---------------------------------------------------------------------------
+# OCR Preprocessing Pipeline
+# ---------------------------------------------------------------------------
+
+def preprocess_for_ocr(input_path: Path, output: Optional[Path] = None) -> Path:
+    """
+    Full OCR preprocessing pipeline:
+      1. Auto orientation detection
+      2. Contrast enhancement
+      3. Noise removal
+      4. Threshold binarization
+    Returns path to the preprocessed image.
+    """
+    try:
+        import cv2
+        import numpy as np
+        from PIL import Image, ImageEnhance, ImageOps
+    except ImportError:
+        abort("opencv-python-headless and Pillow are required.")
+
+    if not input_path.exists():
+        abort(f"File not found: {input_path}")
+
+    info("Step 1/4: Orientation detection...")
+    img_cv = _load_cv2(input_path)
+    gray = cv2.cvtColor(img_cv, cv2.COLOR_BGR2GRAY) if len(img_cv.shape) == 3 else img_cv
+
+    # Deskew
+    inv = cv2.bitwise_not(gray)
+    thresh = cv2.threshold(inv, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
+    coords = cv2.findNonZero(thresh)
+    if coords is not None:
+        angle = cv2.minAreaRect(coords)[-1]
+        if angle < -45:
+            angle = 90 + angle
+        (h, w) = gray.shape[:2]
+        M = cv2.getRotationMatrix2D((w // 2, h // 2), angle, 1.0)
+        gray = cv2.warpAffine(gray, M, (w, h), flags=cv2.INTER_CUBIC, borderMode=cv2.BORDER_REPLICATE)
+
+    info("Step 2/4: Contrast enhancement...")
+    pil_img = Image.fromarray(gray)
+    pil_img = ImageOps.autocontrast(pil_img, cutoff=2)
+    enhancer = ImageEnhance.Contrast(pil_img)
+    pil_img = enhancer.enhance(1.4)
+    gray = __import__("numpy").array(pil_img)
+
+    info("Step 3/4: Noise removal...")
+    gray = cv2.fastNlMeansDenoising(gray, h=10, templateWindowSize=7, searchWindowSize=21)
+
+    info("Step 4/4: Threshold binarization...")
+    binary = cv2.adaptiveThreshold(
+        gray, 255,
+        cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
+        cv2.THRESH_BINARY,
+        blockSize=15,
+        C=4,
+    )
+
+    out = output or input_path.with_name(input_path.stem + "_preprocessed.png")
+    cv2.imwrite(str(out), binary)
+    success(f"Preprocessing complete -> [bold]{out}[/bold]")
+    return out