docome 0.1.0__py3-none-any.whl

cli/docome/commands/__init__.py

@@ -0,0 +1,3 @@
+from .pdf import pdf_app
+
+__all__ = ["pdf_app"]

cli/docome/commands/convert.py

@@ -0,0 +1,335 @@
+import json
+import sys
+from pathlib import Path
+from typing import Optional, List, Tuple
+
+import typer
+from rich.console import Console
+from rich.table import Table
+
+sys.path.insert(0, str(Path(__file__).parent.parent.parent.parent))
+
+from packages.conversion_engine import ConversionEngine, evaluate, pdf_to_docx_hq
+from packages.image_engine import ImageEngine
+
+# Main CLI app - this is added as a subcommand to the main app
+convert_app = typer.Typer(help="Document and image conversion operations")
+console = Console()
+
+# Image engine instance for image conversions
+image_engine = ImageEngine()
+
+# Extension to conversion type mapper
+CONVERSION_MAP = {
+    # Document conversions (PDF-based)
+    (".pdf", ".docx"): "pdf2docx",
+    (".pdf", ".docx-hq"): "pdf2docx-hq",
+    (".pdf", ".xlsx"): "pdf2xlsx",
+    (".pdf", ".pptx"): "pdf2pptx",
+    (".pdf", ".txt"): "pdf2txt",
+    (".pdf", ".md"): "pdf2md",
+    # Reverse document conversions
+    (".docx", ".pdf"): "docx2pdf",
+    # Image conversions (format changes)
+    (".png", ".jpg"): "convert-img",
+    (".png", ".jpeg"): "convert-img",
+    (".png", ".webp"): "convert-img",
+    (".png", ".bmp"): "convert-img",
+    (".png", ".tiff"): "convert-img",
+    (".jpg", ".png"): "convert-img",
+    (".jpg", ".webp"): "convert-img",
+    (".jpg", ".bmp"): "convert-img",
+    (".jpg", ".tiff"): "convert-img",
+    (".webp", ".png"): "convert-img",
+    (".webp", ".jpg"): "convert-img",
+    (".bmp", ".png"): "convert-img",
+    (".bmp", ".jpg"): "convert-img",
+    # Image to PDF
+    (".png", ".pdf"): "img2pdf",
+    (".jpg", ".pdf"): "img2pdf",
+    (".jpeg", ".pdf"): "img2pdf",
+    (".bmp", ".pdf"): "img2pdf",
+    # Compression
+    (".jpg", "compress-img"): "compress-img",
+    (".png", "compress-img"): "compress-img",
+    # Resize
+    (".jpg", "resize-img"): "resize-img",
+    (".png", "resize-img"): "resize-img",
+}
+
+
+def parse_source_dest(source_str: str, dest_str: str) -> Tuple[List[str], List[str]]:
+    """Parse source and destination strings, handling comma-separated lists."""
+    sources = [s.strip() for s in source_str.split(",")]
+    dests = [d.strip() for d in dest_str.split(",")]
+    return sources, dests
+
+
+def get_extension(filepath: str) -> str:
+    """Get file extension from path."""
+    return Path(filepath).suffix.lower()
+
+
+def detect_conversion_type(source: str, dest: str) -> Optional[str]:
+    """Auto-detect conversion type from file extensions."""
+    src_ext = get_extension(source)
+    dst_ext = get_extension(dest)
+
+    # Direct extension mapping from CONVERSION_MAP
+    key = (src_ext, dst_ext)
+    if key in CONVERSION_MAP:
+        return CONVERSION_MAP[key]
+
+    # PDF to document formats (explicit checks after map)
+    if src_ext == ".pdf":
+        if dst_ext == ".docx":
+            return "pdf2docx"
+        if dst_ext == ".docx-hq":
+            return "pdf2docx-hq"
+        if dst_ext == ".xlsx":
+            return "pdf2xlsx"
+        if dst_ext == ".pptx":
+            return "pdf2pptx"
+        if dst_ext == ".txt":
+            return "pdf2txt"
+        if dst_ext == ".md":
+            return "pdf2md"
+
+    # Image to PDF
+    if dst_ext == ".pdf" and src_ext in (".png", ".jpg", ".jpeg", ".bmp", ".webp"):
+        return "img2pdf"
+
+    # Image format conversions (between image formats)
+    if src_ext in (".png", ".jpg", ".jpeg", ".webp", ".bmp") and dst_ext in (".png", ".jpg", ".jpeg", ".webp", ".bmp"):
+        return "convert-img"
+
+    # Fallback: anything to PDF for images already caught above
+    # Fallback: unsupported
+    return None
+
+
+@convert_app.command("convert-files")
+def convert_files(
+    source_and_dest: str = typer.Argument(..., help="Input and output file paths, e.g. 'test.png into output.pdf'"),
+):
+    """Convert files using natural language format.
+
+    Examples:
+        docome convert-files test.png into output.pdf
+        docome convert-files test.png,test2.png into output1.pdf,output2.pdf
+    """
+    console.print(f"[blue]Processing conversion...[/blue]")
+
+    # Parse "source into dest" format
+    if "into" in source_and_dest.lower():
+        parts = source_and_dest.lower().split("into", 1)
+        if len(parts) == 2:
+            source_str = parts[0].strip()
+            dest_str = parts[1].strip()
+        else:
+            source_str = source_and_dest.strip()
+            dest_str = ""
+    else:
+        # No "into" keyword - assume single file conversion or use existing logic
+        source_str = source_and_dest.strip()
+        dest_str = ""
+
+    sources, dests = parse_source_dest(source_str, dest_str)
+
+    if len(sources) != len(dests):
+        console.print(
+            f"[red]Error: Number of source files ({len(sources)}) must match number of destination files ({len(dests)}).[/red]"
+        )
+        raise typer.Exit(code=1)
+
+    # Validate that source files exist
+    for src in sources:
+        if not Path(src).exists():
+            console.print(f"[red]Error: Source file not found: {src}[/red]")
+            raise typer.Exit(code=1)
+
+    engine = ConversionEngine()
+    image_engine_local = ImageEngine()
+
+    for src, dst in zip(sources, dests):
+        src = src.strip()
+        dst = dst.strip()
+
+        console.print(f"[blue]Converting {src} ...[/blue]")
+
+        conv_type = detect_conversion_type(src, dst)
+
+        if conv_type is None:
+            console.print(
+                f"[red]Unsupported conversion from {get_extension(src)} to {get_extension(dst)}[/red]"
+            )
+            raise typer.Exit(code=1)
+
+        # Handle image to PDF (img2pdf) - uses ImageEngine
+        if conv_type == "img2pdf":
+            if src.endswith((".png", ".jpg", ".jpeg", ".bmp", ".webp")):
+                image_engine_local.images_to_pdf([src], dst)
+                console.print(f"[green]PDF saved to: {dst}[/green]")
+            else:
+                console.print(
+                    f"[red]Unsupported image format: {get_extension(src)}[/red]"
+                )
+                raise typer.Exit(code=1)
+
+        # Handle convert-img (format conversion)
+        elif conv_type == "convert-img":
+            if src.endswith((".png", ".jpg", ".jpeg", ".webp", ".bmp")):
+                dst_ext = Path(dst).suffix.lower()
+                output_format = dst_ext.lstrip(".") or "PNG"
+                image_engine_local.convert_image_format(src, dst, output_format)
+                console.print(f"[green]Image saved to: {dst}[/green]")
+            else:
+                console.print(f"[red]Unsupported source format: {get_extension(src)}[/red]")
+                raise typer.Exit(code=1)
+
+        # Handle document conversions using ConversionEngine
+        else:
+            # Map command name to engine method
+            method_map = {
+                "pdf2docx": lambda: engine.pdf_to_docx(src, dst),
+                "pdf2docx-hq": lambda: pdf_to_docx_hq(src, dst),
+                "pdf2xlsx": lambda: engine.pdf_to_xlsx(src, dst),
+                "pdf2pptx": lambda: engine.pdf_to_pptx(src, dst),
+                "pdf2txt": lambda: engine.pdf_to_text(src, dst),
+                "pdf2md": lambda: engine.pdf_to_markdown(src, dst),
+                "docx2pdf": lambda: engine.docx_to_pdf(src, dst),
+            }
+
+            if conv_type in method_map:
+                method_map[conv_type]()
+                console.print(f"[green]{dst} saved successfully[/green]")
+            else:
+                console.print(f"[red]Conversion type {conv_type} not implemented[/red]")
+                raise typer.Exit(code=1)
+
+    console.print(f"[green]All conversions completed![/green]")
+
+
+@convert_app.command("docx2pdf")
+def docx2pdf_cmd(
+    input: str = typer.Argument(..., help="Input DOCX file"),
+    output: str = typer.Option(..., "-o", "--output", help="Output PDF file"),
+):
+    """Convert DOCX to PDF."""
+    console.print(f"[blue]Converting {input} to PDF...[/blue]")
+    engine = ConversionEngine()
+    engine.docx_to_pdf(input, output)
+    console.print(f"[green]PDF saved to: {output}[/green]")
+
+
+@convert_app.command("pdf2docx")
+def pdf2docx_cmd(
+    input: str = typer.Argument(..., help="Input PDF file"),
+    output: str = typer.Option(..., "-o", "--output", help="Output DOCX file"),
+):
+    """Convert PDF to DOCX."""
+    console.print(f"[blue]Converting {input} to DOCX...[/blue]")
+    engine = ConversionEngine()
+    engine.pdf_to_docx(input, output)
+    console.print(f"[green]DOCX saved to: {output}[/green]")
+
+
+@convert_app.command("pdf2docx-hq")
+def pdf2docx_hq_cmd(
+    input: str = typer.Argument(..., help="Input PDF file"),
+    output: str = typer.Option(..., "-o", "--output", help="Output DOCX file"),
+):
+    """Convert PDF to DOCX with high-fidelity reconstruction."""
+    console.print(f"[blue]Converting {input} to DOCX (high fidelity)...[/blue]")
+    from packages.conversion_engine import pdf_to_docx_hq
+    pdf_to_docx_hq(input, output)
+    console.print(f"[green]High-fidelity DOCX saved to: {output}[/green]")
+
+
+@convert_app.command("pdf2txt")
+def pdf2txt_cmd(
+    input: str = typer.Argument(..., help="Input PDF file"),
+    output: Optional[str] = typer.Option(None, "-o", "--output", help="Output text file (optional)"),
+):
+    """Convert PDF to plain text."""
+    console.print(f"[blue]Converting {input} to text...[/blue]")
+    engine = ConversionEngine()
+    text = engine.pdf_to_text(input, output)
+    if output:
+        console.print(f"[green]Text saved to: {output}[/green]")
+    else:
+        console.print(text[:500] + "..." if len(text) > 500 else text)
+
+
+@convert_app.command("pdf2md")
+def pdf2md_cmd(
+    input: str = typer.Argument(..., help="Input PDF file"),
+    output: Optional[str] = typer.Option(None, "-o", "--output", help="Output markdown file (optional)"),
+):
+    """Convert PDF to Markdown."""
+    console.print(f"[blue]Converting {input} to Markdown...[/blue]")
+    engine = ConversionEngine()
+    md = engine.pdf_to_markdown(input, output)
+    if output:
+        console.print(f"[green]Markdown saved to: {output}[/green]")
+    else:
+        console.print(md[:500] + "..." if len(md) > 500 else md)
+
+
+@convert_app.command("img2pdf")
+def img2pdf_cmd(
+    input: str = typer.Argument(..., help="Input image file or list of images separated by comma"),
+    output: str = typer.Option(..., "-o", "--output", help="Output PDF file"),
+):
+    """Convert image(s) to PDF."""
+    console.print(f"[blue]Converting {input} to PDF...[/blue]")
+    if "," in input:
+        image_paths = [p.strip() for p in input.split(",")]
+        image_engine.images_to_pdf(image_paths, output)
+    else:
+        image_engine.images_to_pdf([input], output)
+    console.print(f"[green]PDF saved to: {output}[/green]")
+
+
+@convert_app.command("convert-img")
+def convert_img_cmd(
+    input: str = typer.Argument(..., help="Input image file"),
+    output: str = typer.Option(..., "-o", "--output", help="Output image file"),
+    format: str = typer.Option("PNG", "--format", help="Output format (PNG, JPEG, JPG, BMP, GIF, TIFF, WEBP)"),
+):
+    """Convert image from one format to another."""
+    console.print(f"[blue]Converting {input} to {format}...[/blue]")
+    image_engine.convert_image_format(input, output, format)
+    console.print(f"[green]Image saved to: {output}[/green]")
+
+
+@convert_app.command("compress-img")
+def compress_img_cmd(
+    input: str = typer.Argument(..., help="Input image file"),
+    output: str = typer.Option(..., "-o", "--output", help="Output image file"),
+    quality: int = typer.Option(85, "--quality", help="Compression quality (1-100)"),
+    format: str = typer.Option("JPEG", "--format", help="Output format"),
+):
+    """Compress an image with specified quality."""
+    console.print(f"[blue]Compressing {input}...[/blue]")
+    image_engine.compress_image(input, output, quality=quality, output_format=format)
+    console.print(f"[green]Image saved to: {output}[/green]")
+
+
+@convert_app.command("resize-img")
+def resize_img_cmd(
+    input: str = typer.Argument(..., help="Input image file"),
+    output: str = typer.Option(..., "-o", "--output", help="Output image file"),
+    width: Optional[int] = typer.Option(None, "--width", help="Output width"),
+    height: Optional[int] = typer.Option(None, "--height", help="Output height"),
+    maintain_aspect: bool = typer.Option(True, "--no-maintain-aspect/--maintain-aspect", help="Maintain aspect ratio"),
+):
+    """Resize an image and return transformation info."""
+    console.print(f"[blue]Resizing {input}...[/blue]")
+    info = image_engine.resize_image(input, output, width=width, height=height, maintain_aspect=maintain_aspect)
+    console.print(f"[green]Image saved to: {output}[/green]")
+    console.print(f"[dim]Transformation: {info['original_size']} -> {info['new_size']} (maintain_aspect={info['maintain_aspect']})[/dim]")
+
+
+if __name__ == "__main__":
+    convert_app()