dforge-cli 1.0.1__py3-none-any.whl

dforge/setup.py

@@ -0,0 +1,107 @@
+import subprocess
+from shutil import which
+
+from rich.console import Console
+
+from dforge.config_manager import set_tool_path
+from pathlib import Path
+
+console = Console()
+
+
+def setup_dependencies():
+
+    packages = [
+    ("Poppler", "oschwartz10612.Poppler"),
+    ("Pandoc", "JohnMacFarlane.Pandoc"),
+    ("MiKTeX", "MiKTeX.MiKTeX"),
+    ]
+
+    for name, package_id in packages:
+
+        console.print(
+            f"[cyan]Installing {name}...[/cyan]"
+        )
+
+        subprocess.run(
+            [
+                "winget",
+                "install",
+                "--id",
+                package_id,
+                "-e",
+            ]
+        )
+
+    # Save discovered tools
+
+    pdfinfo = find_pdfinfo()
+    pandoc = find_pandoc()
+    tesseract = which("tesseract")
+    xelatex = find_xelatex()
+    ghostscript = (
+        which("gswin64c")
+        or which("gswin32c")
+        or which("gs")
+    )
+
+    if pdfinfo:
+        set_tool_path("poppler", pdfinfo)
+
+    if pandoc:
+        set_tool_path("pandoc", pandoc)
+    if xelatex:
+        set_tool_path("xelatex", xelatex)
+    if tesseract:
+        set_tool_path("tesseract", tesseract)
+
+    if ghostscript:
+        set_tool_path("ghostscript", ghostscript)
+
+    console.print(
+        "\n[bold green]Setup complete.[/bold green]"
+    )
+def find_pdfinfo():
+    roots = [
+        Path.home() / "AppData/Local/Microsoft/WinGet/Packages",
+        Path("C:/Program Files"),
+    ]
+
+    for root in roots:
+        if root.exists():
+            files = list(root.rglob("pdfinfo.exe"))
+            if files:
+                return str(files[0])
+
+    return None
+
+def find_xelatex():
+    roots = [
+        Path.home() / "AppData/Local/Programs/MiKTeX",
+        Path.home() / "AppData/Local",
+        Path.home() / "AppData/Local/Microsoft/WinGet/Packages",
+        Path("C:/Program Files"),
+    ]
+
+    for root in roots:
+        if root.exists():
+            files = list(root.rglob("xelatex.exe"))
+            if files:
+                return str(files[0])
+
+    return None
+
+def find_pandoc():
+    roots = [
+        Path.home() / "AppData/Local/Pandoc",
+        Path("C:/Program Files"),
+        Path.home() / "AppData/Local/Microsoft/WinGet/Packages"
+    ]
+
+    for root in roots:
+        if root.exists():
+            files = list(root.rglob("pandoc.exe"))
+            if files:
+                return str(files[0])
+
+    return None

dforge/theme.py

@@ -0,0 +1,12 @@
+from rich.theme import Theme
+
+DFORGE_THEME = Theme(
+    {
+        "title": "bold cyan",
+        "success": "bold green",
+        "warning": "bold yellow",
+        "error": "bold red",
+        "menu": "bold white",
+        "accent": "cyan",
+    }
+)

dforge/utils.py

@@ -0,0 +1,169 @@
+"""
+DForge Utilities - Shared helpers used across all modules.
+"""
+
+from __future__ import annotations
+import json
+import shutil
+import sys
+from pathlib import Path
+from typing import List, Optional
+
+from rich.console import Console
+from rich.panel import Panel
+from rich.text import Text
+
+console = Console()
+
+
+
+
+CONFIG_FILE = Path.cwd() / ".dforge.json"
+
+
+def save_recent_folder(folder: str):
+    try:
+        data = {"recent_folder": folder}
+
+        CONFIG_FILE.write_text(
+            json.dumps(data, indent=4)
+        )
+
+
+    except Exception as e:
+        print("ERROR:", e)
+
+
+def load_recent_folder():
+    if not CONFIG_FILE.exists():
+        return None
+
+    try:
+        return json.loads(
+            CONFIG_FILE.read_text()
+        ).get("recent_folder")
+    except Exception:
+        return None
+# ---------------------------------------------------------------------------
+# Output path helpers
+# ---------------------------------------------------------------------------
+
+def resolve_output(
+    input_path: Path,
+    output: Optional[str],
+    suffix: str,
+    ext: Optional[str] = None,
+) -> Path:
+    """
+    Resolve where to write the output file.
+
+    If `output` is given -> use it.
+    Otherwise derive a name from the input path + suffix + optional new extension.
+
+    Example:
+        resolve_output(Path("doc.pdf"), None, "_merged", ".pdf")
+        -> Path("doc_merged.pdf")
+    """
+    if output:
+        return Path(output)
+    src = Path(input_path)
+    new_ext = ext if ext is not None else src.suffix
+    return src.with_name(src.stem + suffix + new_ext)
+
+
+def ensure_parent(path: Path) -> None:
+    """Create parent directories for path if they don't exist."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+
+
+# ---------------------------------------------------------------------------
+# Dependency checks
+# ---------------------------------------------------------------------------
+
+def require_tool(tool: str, install_hint: str = "") -> None:
+    """Abort with a helpful message if an external tool is not on PATH."""
+    if shutil.which(tool) is None:
+        msg = f"[bold red]Missing dependency:[/bold red] '{tool}' was not found on PATH."
+        if install_hint:
+            msg += f"\n[dim]{install_hint}[/dim]"
+        console.print(Panel(msg, title="[red]Dependency Error[/red]", border_style="red"))
+        sys.exit(1)
+
+
+def require_tesseract() -> None:
+    require_tool(
+        "tesseract",
+        "Install Tesseract: https://tesseract-ocr.github.io/tessdoc/Installation.html",
+    )
+
+
+def require_ghostscript() -> None:
+    for candidate in ("gs", "gswin64c", "gswin32c"):
+        if shutil.which(candidate):
+            return
+    console.print(
+        Panel(
+            "[bold red]Missing dependency:[/bold red] 'Ghostscript' was not found on PATH.\n"
+            "[dim]Install from https://ghostscript.com/releases/gsdnld.html[/dim]",
+            title="[red]Dependency Error[/red]",
+            border_style="red",
+        )
+    )
+    sys.exit(1)
+
+
+def require_pandoc() -> None:
+    require_tool(
+        "pandoc",
+        "Install Pandoc: https://pandoc.org/installing.html",
+    )
+
+
+def ghostscript_bin() -> str:
+    """Return the first available Ghostscript binary name."""
+    for candidate in ("gs", "gswin64c", "gswin32c"):
+        if shutil.which(candidate):
+            return candidate
+    return "gs"  # fallback (will fail gracefully)
+
+
+# ---------------------------------------------------------------------------
+# Pretty printing helpers
+# ---------------------------------------------------------------------------
+
+def success(msg: str) -> None:
+    console.print(f"[bold green]OK[/bold green]  {msg}")
+
+
+def info(msg: str) -> None:
+    console.print(f"[bold cyan]INFO[/bold cyan]  {msg}")
+
+
+def warn(msg: str) -> None:
+    console.print(f"[bold yellow]WARN[/bold yellow]  {msg}")
+
+
+def error(msg: str) -> None:
+    console.print(f"[bold red]ERROR[/bold red]  {msg}")
+
+
+def abort(msg: str) -> None:
+    error(msg)
+    sys.exit(1)
+
+
+# ---------------------------------------------------------------------------
+# File collection helpers
+# ---------------------------------------------------------------------------
+
+def collect_files(
+    directory: Path,
+    extensions: set[str],
+    recursive: bool = True,
+) -> List[Path]:
+    """Collect all files with the given extensions from a directory."""
+    pattern = "**/*" if recursive else "*"
+    files = []
+    for ext in extensions:
+        files.extend(directory.glob(f"{pattern}{ext}"))
+    return sorted(set(files))

dforge/watcher.py

@@ -0,0 +1,137 @@
+"""
+DForge Watch Mode
+Monitors a directory for new files and automatically processes them.
+"""
+
+from __future__ import annotations
+
+import time
+from pathlib import Path
+
+from dforge.utils import abort, console, info, success, warn
+from dforge.config import (
+    DEFAULT_OCR_LANG,
+    SUPPORTED_IMAGE_EXTS,
+    SUPPORTED_PDF_EXTS,
+    WATCH_DEBOUNCE_SECONDS,
+)
+
+
+# ---------------------------------------------------------------------------
+# Event handler
+# ---------------------------------------------------------------------------
+
+class _DForgeHandler:
+    """Handles file-system events and dispatches to the correct action."""
+
+    def __init__(self, action: str, lang: str, fmt: str):
+        self.action = action
+        self.lang = lang
+        self.fmt = fmt
+        self._seen: set = set()
+
+    def dispatch(self, path: Path) -> None:
+        if path in self._seen:
+            return
+        self._seen.add(path)
+
+        # Debounce: wait for the file to finish writing
+        time.sleep(WATCH_DEBOUNCE_SECONDS)
+        if not path.exists():
+            return
+
+        ext = path.suffix.lower()
+        console.print(f"\n[bold cyan]-> Detected:[/bold cyan] {path.name}")
+
+        try:
+            if self.action == "ocr":
+                if ext == ".pdf":
+                    from dforge.ocr.engine import ocr_pdf
+                    ocr_pdf(path, lang=self.lang, fmt=self.fmt)
+                elif ext in SUPPORTED_IMAGE_EXTS:
+                    from dforge.ocr.engine import ocr_image
+                    ocr_image(path, lang=self.lang, fmt=self.fmt)
+                else:
+                    warn(f"Skipped (unsupported for OCR): {path.name}")
+
+            elif self.action == "searchable":
+                if ext == ".pdf":
+                    from dforge.ocr.engine import make_searchable_pdf
+                    make_searchable_pdf(path, lang=self.lang)
+                else:
+                    warn(f"Skipped (not a PDF): {path.name}")
+
+            elif self.action == "compress":
+                if ext == ".pdf":
+                    from dforge.pdf.operations import compress
+                    compress(path)
+                else:
+                    warn(f"Skipped (not a PDF): {path.name}")
+
+            elif self.action == "preprocess":
+                if ext in SUPPORTED_IMAGE_EXTS:
+                    from dforge.image.processor import preprocess_for_ocr
+                    preprocess_for_ocr(path)
+                else:
+                    warn(f"Skipped (not an image): {path.name}")
+
+            else:
+                warn(f"Unknown watch action: {self.action}")
+
+        except Exception as exc:
+            console.print(f"[red]Error processing {path.name}:[/red] {exc}")
+
+
+# ---------------------------------------------------------------------------
+# Watch entry point
+# ---------------------------------------------------------------------------
+
+def watch(
+    directory: Path,
+    action: str = "ocr",
+    lang: str = DEFAULT_OCR_LANG,
+    fmt: str = "txt",
+) -> None:
+    """
+    Monitor a directory and process new files automatically.
+
+    action: ocr | searchable | compress | preprocess
+    """
+    try:
+        from watchdog.observers import Observer
+        from watchdog.events import FileSystemEventHandler
+    except ImportError:
+        abort("watchdog is required. Run: pip install watchdog")
+
+    if not directory.exists():
+        abort(f"Directory not found: {directory}")
+
+    handler_state = _DForgeHandler(action=action, lang=lang, fmt=fmt)
+
+    class _WatchdogBridge(FileSystemEventHandler):
+        def on_created(self, event):
+            if not event.is_directory:
+                handler_state.dispatch(Path(event.src_path))
+
+        def on_moved(self, event):
+            if not event.is_directory:
+                handler_state.dispatch(Path(event.dest_path))
+
+    observer = Observer()
+    observer.schedule(_WatchdogBridge(), str(directory), recursive=True)
+    observer.start()
+
+    console.print(
+        f"\n[bold green]Watching[/bold green] [bold]{directory}[/bold] "
+        f"for new files (action: [cyan]{action}[/cyan])\n"
+        "[dim]Press Ctrl+C to stop.[/dim]\n"
+    )
+
+    try:
+        while True:
+            time.sleep(1)
+    except KeyboardInterrupt:
+        observer.stop()
+        info("Watch mode stopped.")
+
+    observer.join()

dforge/workflows/automation.py

@@ -0,0 +1,21 @@
+from dforge.menu import automation_menu
+
+
+def automation_workflow():
+    while True:
+        choice = automation_menu()
+
+        if choice == "Watch Folder":
+            pass
+
+        elif choice == "Auto OCR":
+            pass
+
+        elif choice == "Auto Convert":
+            pass
+
+        elif choice == "Scheduled Tasks":
+            pass
+
+        elif choice == "⬅ Back":
+            break

dforge/workflows/batch.py

@@ -0,0 +1,18 @@
+from dforge.menu import batch_menu
+
+
+def batch_workflow():
+    while True:
+        choice = batch_menu()
+
+        if choice == "Batch Convert":
+            pass
+
+        elif choice == "Batch Compress":
+            pass
+
+        elif choice == "Batch OCR":
+            pass
+
+        elif choice == "⬅ Back":
+            break

dforge/workflows/batch_ocr.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+from dforge.loading import Loader
+from dforge.batch import batch_with_ocr
+
+from dforge.workflows.common import (
+    select_folder,
+    success_screen,
+)
+
+console = Console()
+
+
+def batch_ocr_workflow():
+    console.print(
+        "\n[bold cyan]Batch OCR[/bold cyan]\n"
+    )
+
+    folder = select_folder()
+
+    if not folder:
+        return
+
+    lang = questionary.text(
+        "OCR Language(s)",
+        default="eng",
+    ).ask()
+
+    fmt = questionary.select(
+        "Output Format",
+        choices=[
+            "txt",
+            "json",
+            "md",
+        ],
+    ).ask()
+
+    workers = int(
+        questionary.text(
+            "Workers",
+            default="4",
+        ).ask()
+    )
+    with Loader("Processing batch OCR..."):
+        batch_with_ocr(
+            Path(folder),
+            lang,
+            fmt,
+            True,
+            workers,
+        )
+
+    success_screen(
+        "Batch OCR Complete",
+        extra_lines=[
+            f"Folder  : {folder}",
+            f"Workers : {workers}",
+        ],
+    )

dforge/workflows/common.py

@@ -0,0 +1,133 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+from rich.panel import Panel
+
+from dforge.utils import save_recent_folder, load_recent_folder
+
+console = Console()
+
+
+def select_folder():
+    recent_folder = load_recent_folder()
+
+    choices = []
+
+    if recent_folder and Path(recent_folder).exists():
+        choices.append(
+            f"Recent Folder ({Path(recent_folder).name})"
+        )
+
+    choices.extend([
+        "Current Folder",
+        "Choose Folder",
+    ])
+
+    mode = questionary.select(
+        "How would you like to select files?",
+        choices=choices,
+    ).ask()
+
+    if mode and mode.startswith("Recent Folder"):
+        return Path(recent_folder)
+
+    if mode == "Current Folder":
+        return Path(".")
+
+    folder_path = questionary.path(
+        "Folder containing PDFs:"
+    ).ask()
+
+    if not folder_path:
+        return None
+
+    folder = Path(folder_path)
+
+    save_recent_folder(str(folder))
+
+    return folder
+
+
+def select_multiple_pdfs():
+    folder = select_folder()
+
+    if not folder:
+        return None, None
+
+    pdfs = sorted(folder.glob("*.pdf"))
+
+    if not pdfs:
+        console.print(
+            "[red]No PDF files found.[/red]"
+        )
+        return None, None
+
+    selected = questionary.checkbox(
+        "Select PDFs",
+        choices=[pdf.name for pdf in pdfs],
+    ).ask()
+
+    if not selected:
+        return None, None
+
+    return folder, selected
+
+
+def select_single_pdf():
+    folder = select_folder()
+
+    if not folder:
+        return None
+
+    pdfs = sorted(folder.glob("*.pdf"))
+
+    if not pdfs:
+        console.print(
+            "[red]No PDF files found.[/red]"
+        )
+        return None
+
+    selected = questionary.select(
+        "Select PDF",
+        choices=[pdf.name for pdf in pdfs],
+    ).ask()
+
+    if not selected:
+        return None
+
+    return folder / selected
+
+
+def success_screen(
+    title,
+    output_file=None,
+    extra_lines=None,
+):
+    body = f"✓ {title}\n"
+
+    if output_file:
+        body += f"\nOutput File : {output_file}"
+
+    if extra_lines:
+        for line in extra_lines:
+            body += f"\n{line}"
+
+    console.print()
+
+    console.print(
+        Panel(
+            body,
+            title="Success",
+            border_style="green",
+        )
+    )
+
+    console.print()
+
+
+def get_output_name(default_name):
+    return questionary.text(
+        "Output file:",
+        default=default_name,
+    ).ask()