dforge-cli 1.0.1__py3-none-any.whl

dforge/workflows/compress.py

@@ -0,0 +1,73 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.operations import compress
+
+from dforge.workflows.common import (
+    select_single_pdf,
+    success_screen,
+    get_output_name,
+)
+
+console = Console()
+
+
+def compress_workflow():
+    console.print("\n[bold cyan]Compress PDF[/bold cyan]\n")
+
+    pdf = select_single_pdf()
+
+    if not pdf:
+        return
+
+    preset = questionary.select(
+        "Compression Preset",
+        choices=[
+            "screen",
+            "ebook",
+            "printer",
+            "prepress",
+            "default",
+        ],
+    ).ask()
+
+    output = get_output_name(
+        f"{pdf.stem}_compressed.pdf"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+    console.print(
+        "\n[bold cyan]Compressing PDF...[/bold cyan]\n"
+    )
+
+    compress(
+        pdf,
+        output_path,
+        preset,
+    )
+
+    success_screen(
+        "Compression Complete",
+        output_file=output_path.name,
+        extra_lines=[
+            f"Preset     : {preset}",
+            f"Location   : {output_path.resolve()}",
+        ],
+    )
+
+    next_action = questionary.select(
+        "What next?",
+        choices=[
+            "Compress Another PDF",
+            "Back to PDF Tools",
+        ],
+    ).ask()
+
+    if next_action == "Compress Another PDF":
+        compress_workflow()

dforge/workflows/convert.py

@@ -0,0 +1,148 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.converter import (
+    convert,
+    images_to_pdf,
+    pdf_to_images,
+)
+from dforge.menu import conversion_menu
+from dforge.workflows.common import success_screen
+
+console = Console()
+
+
+def markdown_to_pdf_workflow():
+    source = questionary.path(
+        "Markdown file:"
+    ).ask()
+
+    if not source:
+        return
+
+    convert(Path(source), "pdf")
+
+    success_screen(
+        "Conversion Complete"
+    )
+
+
+def markdown_to_docx_workflow():
+    source = questionary.path(
+        "Markdown file:"
+    ).ask()
+
+    if not source:
+        return
+
+    convert(Path(source), "docx")
+
+    success_screen(
+        "Conversion Complete"
+    )
+
+
+def docx_to_pdf_workflow():
+    source = questionary.path(
+        "DOCX file:"
+    ).ask()
+
+    if not source:
+        return
+
+    convert(Path(source), "pdf")
+
+    success_screen(
+        "Conversion Complete"
+    )
+
+
+def docx_to_markdown_workflow():
+    source = questionary.path(
+        "DOCX file:"
+    ).ask()
+
+    if not source:
+        return
+
+    convert(Path(source), "md")
+
+    success_screen(
+        "Conversion Complete"
+    )
+
+
+def images_to_pdf_workflow():
+    source = questionary.path(
+        "Image file or folder:"
+    ).ask()
+
+    if not source:
+        return
+
+    images_to_pdf(
+        Path(source)
+    )
+
+    success_screen(
+        "Conversion Complete"
+    )
+
+
+def pdf_to_images_workflow():
+    source = questionary.path(
+        "PDF file:"
+    ).ask()
+
+    if not source:
+        return
+
+    fmt = questionary.select(
+        "Image format:",
+        choices=[
+            "png",
+            "jpeg",
+            "tiff",
+        ],
+    ).ask()
+
+    if not fmt:
+        return
+
+    pdf_to_images(
+        Path(source),
+        fmt=fmt,
+    )
+
+    success_screen(
+        "Conversion Complete"
+    )
+
+
+def conversion_workflow():
+    while True:
+
+        choice = conversion_menu()
+
+        if choice == "Markdown → PDF":
+            markdown_to_pdf_workflow()
+
+        elif choice == "Markdown → DOCX":
+            markdown_to_docx_workflow()
+
+        elif choice == "DOCX → PDF":
+            docx_to_pdf_workflow()
+
+        elif choice == "DOCX → Markdown":
+            docx_to_markdown_workflow()
+
+        elif choice == "Images → PDF":
+            images_to_pdf_workflow()
+
+        elif choice == "PDF → Images":
+            pdf_to_images_workflow()
+
+        elif choice == "⬅ Back":
+            break

dforge/workflows/decrypt.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.operations import decrypt
+
+from dforge.workflows.common import (
+    select_single_pdf,
+    success_screen,
+    get_output_name,
+)
+
+console = Console()
+
+
+def decrypt_workflow():
+    console.print("\n[bold cyan]Decrypt PDF[/bold cyan]\n")
+
+    pdf = select_single_pdf()
+
+    if not pdf:
+        return
+
+    password = questionary.password(
+        "Password:"
+    ).ask()
+
+    if not password:
+        return
+
+    output = get_output_name(
+        f"{pdf.stem}_decrypted.pdf"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+    decrypt(
+        pdf,
+        password,
+        output_path,
+    )
+
+    success_screen(
+        "Decryption Complete",
+        output_file=output_path.name,
+    )

dforge/workflows/encrypt.py

@@ -0,0 +1,50 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.operations import encrypt
+
+from dforge.workflows.common import (
+    select_single_pdf,
+    success_screen,
+    get_output_name,
+)
+
+console = Console()
+
+
+def encrypt_workflow():
+    console.print("\n[bold cyan]Encrypt PDF[/bold cyan]\n")
+
+    pdf = select_single_pdf()
+
+    if not pdf:
+        return
+
+    password = questionary.password(
+        "Password:"
+    ).ask()
+
+    if not password:
+        return
+
+    output = get_output_name(
+        f"{pdf.stem}_encrypted.pdf"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+    encrypt(
+        pdf,
+        password,
+        output_path,
+    )
+
+    success_screen(
+        "Encryption Complete",
+        output_file=output_path.name,
+    )

dforge/workflows/extract.py

@@ -0,0 +1,18 @@
+from dforge.menu import extract_menu
+
+
+def extract_workflow():
+    while True:
+        choice = extract_menu()
+
+        if choice == "Extract Text":
+            pass
+
+        elif choice == "Extract Images":
+            pass
+
+        elif choice == "Extract Metadata":
+            pass
+
+        elif choice == "⬅ Back":
+            break

dforge/workflows/image.py

@@ -0,0 +1,21 @@
+from dforge.menu import image_menu
+
+
+def image_workflow():
+    while True:
+        choice = image_menu()
+
+        if choice == "Resize Images":
+            pass
+
+        elif choice == "Convert Format":
+            pass
+
+        elif choice == "Crop Images":
+            pass
+
+        elif choice == "Watermark Images":
+            pass
+
+        elif choice == "⬅ Back":
+            break

dforge/workflows/merge.py

@@ -0,0 +1,109 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.operations import merge
+
+from dforge.workflows.common import (
+    select_multiple_pdfs,
+    success_screen,
+    get_output_name,
+)
+
+console = Console()
+
+
+def merge_workflow():
+    console.print("\n[bold cyan]Merge PDFs[/bold cyan]\n")
+
+    folder, selected = select_multiple_pdfs()
+
+    if not folder or not selected:
+        return
+
+    if len(selected) < 2:
+        console.print(
+            "[red]Select at least 2 PDFs.[/red]"
+        )
+        return
+
+    console.print("\n[bold cyan]Selected PDFs[/bold cyan]\n")
+
+    for i, pdf in enumerate(selected, start=1):
+        console.print(f"{i}. {pdf}")
+
+    console.print(
+        f"\n[green]Total PDFs:[/green] {len(selected)}\n"
+    )
+
+    if not questionary.confirm(
+        "Continue?",
+        default=True,
+    ).ask():
+        return
+
+    sort_mode = questionary.select(
+        "Sort PDFs before merging?",
+        choices=[
+            "Keep Current Order",
+            "Alphabetical",
+            "Reverse Alphabetical",
+        ],
+    ).ask()
+
+    if sort_mode == "Alphabetical":
+        selected.sort()
+
+    elif sort_mode == "Reverse Alphabetical":
+        selected.sort(reverse=True)
+
+    output = get_output_name(
+        f"merged_{len(selected)}_files.pdf"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+    if output_path.exists():
+
+        overwrite = questionary.confirm(
+            f"{output} already exists. Overwrite?",
+            default=False,
+        ).ask()
+
+        if not overwrite:
+            return
+
+    console.print(
+        "\n[bold cyan]Merging PDFs...[/bold cyan]\n"
+    )
+
+    inputs = [
+        folder / pdf
+        for pdf in selected
+    ]
+
+    merge(inputs, output_path)
+
+    success_screen(
+        "Merge Complete",
+        output_file=output_path.name,
+        extra_lines=[
+            f"Input Files : {len(selected)}",
+            f"Location    : {output_path.resolve()}",
+        ],
+    )
+
+    next_action = questionary.select(
+        "What next?",
+        choices=[
+            "Merge More PDFs",
+            "Back to PDF Tools",
+        ],
+    ).ask()
+
+    if next_action == "Merge More PDFs":
+        merge_workflow()

dforge/workflows/ocr.py

@@ -0,0 +1,104 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+from dforge.loading import Loader
+from dforge.engine import ocr_image, ocr_pdf
+from dforge.dependencies import has_poppler
+from dforge.workflows.common import (
+    success_screen,
+    get_output_name,
+)
+from dforge.dependencies import (
+    check_poppler,
+    check_tesseract,
+)
+
+console = Console()
+
+
+
+
+def ocr_workflow():
+    if not check_tesseract():
+        return
+    
+    input_file = questionary.path(
+        "Image or PDF file:"
+    ).ask()
+
+    if not input_file:
+        return
+
+    input_file = Path(input_file)
+
+    if input_file.suffix.lower() == ".pdf":
+        if not check_poppler():
+            return
+    console.print("\n[bold cyan]OCR Image / PDF[/bold cyan]\n")
+
+
+    if not input_file:
+        return
+
+    input_file = Path(input_file)
+
+    lang = questionary.text(
+        "OCR Language(s)",
+        default="eng",
+    ).ask()
+
+    fmt = questionary.select(
+        "Output Format",
+        choices=[
+            "txt",
+            "json",
+            "md",
+        ],
+    ).ask()
+
+    output = get_output_name(
+        f"{input_file.stem}_ocr.{fmt}"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+
+    with Loader("Running OCR..."):
+         ocr_pdf(
+            input_file,
+            output_path,
+            lang,
+        )
+
+    if input_file.suffix.lower() == ".pdf":
+        ocr_pdf(
+            input_file,
+            output_path,
+            lang,
+            fmt,
+        )
+    else:
+        ocr_image(
+            input_file,
+            output_path,
+            lang,
+            fmt,
+        )
+
+    success_screen(
+        "OCR Complete",
+        output_file=output_path.name,
+        extra_lines=[
+            f"Format : {fmt}",
+            f"Lang   : {lang}",
+        ],
+    )
+    if not has_poppler():
+        console.print(
+            "[red]Poppler not installed.[/red]"
+        )
+        return

dforge/workflows/pages.py

@@ -0,0 +1,57 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.operations import extract_pages
+
+from dforge.workflows.common import (
+    select_single_pdf,
+    success_screen,
+    get_output_name,
+)
+
+console = Console()
+
+
+def pages_workflow():
+    console.print("\n[bold cyan]Extract Pages[/bold cyan]\n")
+
+    pdf = select_single_pdf()
+
+    if not pdf:
+        return
+
+    page_range = questionary.text(
+        'Page range (Examples: 1-5, 3, 1,3,5)'
+    ).ask()
+
+    if not page_range:
+        return
+
+    output = get_output_name(
+        f"{pdf.stem}_pages.pdf"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+    console.print(
+        "\n[bold cyan]Extracting Pages...[/bold cyan]\n"
+    )
+
+    extract_pages(
+        pdf,
+        page_range,
+        output_path,
+    )
+
+    success_screen(
+        "Page Extraction Complete",
+        output_file=output_path.name,
+        extra_lines=[
+            f"Pages : {page_range}",
+        ],
+    )

dforge/workflows/rotate.py

@@ -0,0 +1,53 @@
+from pathlib import Path
+
+import questionary
+from rich.console import Console
+
+from dforge.operations import rotate
+
+from dforge.workflows.common import (
+    select_single_pdf,
+    success_screen,
+    get_output_name,
+)
+
+console = Console()
+
+
+def rotate_workflow():
+    console.print("\n[bold cyan]Rotate PDF[/bold cyan]\n")
+
+    pdf = select_single_pdf()
+
+    if not pdf:
+        return
+
+    degrees = int(
+        questionary.select(
+            "Rotation",
+            choices=["90", "180", "270"],
+        ).ask()
+    )
+
+    output = get_output_name(
+        f"{pdf.stem}_rotated.pdf"
+    )
+
+    if not output:
+        return
+
+    output_path = Path(output)
+
+    rotate(
+        pdf,
+        degrees,
+        output_path,
+    )
+
+    success_screen(
+        "Rotation Complete",
+        output_file=output_path.name,
+        extra_lines=[
+            f"Rotation : {degrees}°",
+        ],
+    )