anyconvert 0.1.0__py3-none-any.whl

anyconvert/__init__.py

@@ -0,0 +1,75 @@
+"""anyconvert: Enterprise document conversion engine in pure Python.
+
+High-performance, zero-dependency PDF document conversion to DOCX, PPTX, ODT, ODP,
+and TXT with mathematical precision and dual-mode layout reconstruction.
+"""
+
+from __future__ import annotations
+
+from anyconvert.api import (
+    ConversionMode,
+    convert,
+    convert_bytes,
+    pdf_to_document_ir,
+)
+from anyconvert.exceptions import (
+    AnyConvertError,
+    EmitterError,
+    IRBuilderError,
+    IRError,
+    IRValidationError,
+    LayoutError,
+    PackagingError,
+    PDFFontError,
+    PDFError,
+    PDFObjectError,
+    PDFPasswordRequiredError,
+    PDFSecurityError,
+    PDFStreamError,
+    PDFSyntaxError,
+    PDFUnsupportedFilterError,
+    SerializationError,
+    SpatialIndexError,
+    TableReconstructionError,
+    UnsupportedFormatError,
+    XYCutError,
+)
+from anyconvert.ir.model import DocumentIR, DocumentPage
+from anyconvert.pdf.document import PDFDocument
+
+__version__ = "0.1.0"
+__author__ = "anyconvert contributors"
+__license__ = "GPL-3.0-or-later"
+
+__all__ = [
+    "__version__",
+    "__author__",
+    "__license__",
+    "convert",
+    "convert_bytes",
+    "pdf_to_document_ir",
+    "ConversionMode",
+    "DocumentIR",
+    "DocumentPage",
+    "PDFDocument",
+    "AnyConvertError",
+    "PDFError",
+    "PDFSyntaxError",
+    "PDFObjectError",
+    "PDFSecurityError",
+    "PDFPasswordRequiredError",
+    "PDFUnsupportedFilterError",
+    "PDFFontError",
+    "PDFStreamError",
+    "LayoutError",
+    "SpatialIndexError",
+    "XYCutError",
+    "TableReconstructionError",
+    "IRError",
+    "IRValidationError",
+    "IRBuilderError",
+    "EmitterError",
+    "PackagingError",
+    "SerializationError",
+    "UnsupportedFormatError",
+]

anyconvert/__main__.py

@@ -0,0 +1,10 @@
+"""Package invocation entrypoint for python -m anyconvert."""
+
+from __future__ import annotations
+
+import sys
+
+from anyconvert.cli import main
+
+if __name__ == "__main__":
+    sys.exit(main())

anyconvert/api.py

@@ -0,0 +1,229 @@
+"""High-level conversion API for anyconvert.
+
+Provides zero-dependency unified conversion functions:
+- convert(): Convert from file path, Path, or bytes to target format file or bytes.
+- convert_bytes(): Convert from in-memory PDF bytes to target format bytes.
+- pdf_to_document_ir(): Parse a PDF into a validated DocumentIR hierarchy.
+"""
+
+from __future__ import annotations
+
+import pathlib
+from typing import Any, Dict, List, Optional, Sequence, Set, Tuple, Union
+
+from anyconvert.common.reader import ByteReader
+from anyconvert.emitters.base import BaseEmitter, ConversionMode
+from anyconvert.emitters.docx import DocxEmitter
+from anyconvert.emitters.odp import OdpEmitter
+from anyconvert.emitters.odt import OdtEmitter
+from anyconvert.emitters.pptx import PptxEmitter
+from anyconvert.emitters.txt import TxtEmitter
+from anyconvert.exceptions import (
+    AnyConvertError,
+    PDFSyntaxError,
+    UnsupportedFormatError,
+)
+from anyconvert.ir.builder import DocumentIRBuilder
+from anyconvert.ir.model import DocumentIR, DocumentPage
+from anyconvert.layout.cluster import cluster_characters_to_words, cluster_words_to_lines
+from anyconvert.layout.flow import detect_repeating_headers_footers
+from anyconvert.pdf.content.interpreter import ContentInterpreter, InterpreterOutput
+from anyconvert.pdf.document import PDFDocument
+from anyconvert.pdf.parser import PDFArray, PDFDict, PDFIndirectRef
+
+SUPPORTED_FORMATS: Set[str] = {"docx", "pptx", "odt", "odp", "txt"}
+
+
+def _resolve_conversion_mode(mode: Union[ConversionMode, str]) -> ConversionMode:
+    """Normalize and validate ConversionMode from string or enum."""
+    if isinstance(mode, ConversionMode):
+        return mode
+    if isinstance(mode, str):
+        normalized = mode.lower().strip()
+        if normalized == "flow":
+            return ConversionMode.FLOW
+        elif normalized == "canvas":
+            return ConversionMode.CANVAS
+        raise ValueError(
+            f"Invalid conversion mode: '{mode}'. Must be 'flow' or 'canvas'."
+        )
+    raise TypeError(f"Invalid mode type: {type(mode).__name__}. Must be ConversionMode or str.")
+
+
+def _get_emitter(output_format: str) -> BaseEmitter:
+    """Instantiate and return the appropriate emitter for the requested format."""
+    fmt = output_format.lower().strip().lstrip(".")
+    if fmt == "docx":
+        return DocxEmitter()
+    elif fmt == "pptx":
+        return PptxEmitter()
+    elif fmt == "odt":
+        return OdtEmitter()
+    elif fmt == "odp":
+        return OdpEmitter()
+    elif fmt == "txt":
+        return TxtEmitter()
+    raise UnsupportedFormatError(
+        format_name=output_format,
+        supported_formats=sorted(list(SUPPORTED_FORMATS)),
+    )
+
+
+def pdf_to_document_ir(
+    source: Union[str, pathlib.Path, bytes, bytearray, memoryview, ByteReader],
+    password: str = "",
+    mode: Union[ConversionMode, str] = ConversionMode.FLOW,
+) -> DocumentIR:
+    """Parse a PDF document source into a fully validated DocumentIR hierarchy.
+
+    Args:
+        source: File path, Path, raw bytes, or ByteReader.
+        password: Optional decryption password for encrypted PDFs.
+        mode: Layout conversion mode (ConversionMode.FLOW or ConversionMode.CANVAS).
+
+    Returns:
+        DocumentIR: Validated intermediate representation of the document.
+
+    Raises:
+        PDFSyntaxError: If the PDF structure is corrupted or contains no pages.
+        PDFPasswordRequiredError: If the document is password-protected and an incorrect or empty password was given.
+    """
+    conv_mode = _resolve_conversion_mode(mode)
+    reader: ByteReader
+    if isinstance(source, (str, pathlib.Path)):
+        raw_bytes = pathlib.Path(source).read_bytes()
+        reader = ByteReader(raw_bytes)
+    elif isinstance(source, ByteReader):
+        reader = source
+    elif isinstance(source, (bytes, bytearray, memoryview)):
+        reader = ByteReader(source)
+    else:
+        raise TypeError(f"Unsupported source type: {type(source).__name__}")
+
+    doc = PDFDocument(reader, password=password)
+
+    if doc.page_count == 0:
+        raise PDFSyntaxError("PDF contains no valid pages")
+
+    ir_builder = DocumentIRBuilder(resolver=doc.resolver)
+    pages: List[DocumentPage] = []
+
+    interpreted_pages: List[Tuple[InterpreterOutput, float, float]] = []
+    pages_lines: List[List[Any]] = []
+
+    for page_idx in range(doc.page_count):
+        page_dict = doc.get_page(page_idx)
+        x0, y0, x1, y1 = doc.get_page_box(page_dict)
+        page_w = max(1.0, abs(x1 - x0))
+        page_h = max(1.0, abs(y1 - y0))
+
+        # Resolve resources dictionary
+        raw_res = page_dict.get("Resources")
+        if isinstance(raw_res, PDFIndirectRef):
+            raw_res = doc.resolver.dereference(raw_res)
+        page_res = raw_res if isinstance(raw_res, PDFDict) else PDFDict()
+
+        # Decompress / decrypt content streams
+        content_bytes = doc.get_page_content_bytes(page_dict)
+
+        # Interpret content streams
+        interpreter = ContentInterpreter(resources=page_res, resolver=doc.resolver)
+        output = interpreter.interpret(content_bytes)
+        interpreted_pages.append((output, page_w, page_h))
+
+        words = cluster_characters_to_words(output.text_elements, page_height=page_h)
+        lines = cluster_words_to_lines(words)
+        pages_lines.append(lines)
+
+    known_headers: Set[str] = set()
+    known_footers: Set[str] = set()
+    if len(pages_lines) > 1:
+        known_headers, known_footers = detect_repeating_headers_footers(pages_lines)
+
+    for page_idx, (output, page_w, page_h) in enumerate(interpreted_pages):
+        built_page = ir_builder.build_page(
+            output=output,
+            page_width=page_w,
+            page_height=page_h,
+            page_number=page_idx + 1,
+            known_headers=known_headers,
+            known_footers=known_footers,
+            mode=conv_mode,
+        )
+        pages.append(built_page)
+
+    metadata = doc.get_metadata()
+    return ir_builder.build_document(pages, metadata=metadata)
+
+
+def convert(
+    input_path: Union[str, pathlib.Path, bytes, bytearray, memoryview, ByteReader],
+    output_format: str = "docx",
+    output_path: Optional[Union[str, pathlib.Path]] = None,
+    mode: Union[ConversionMode, str] = ConversionMode.FLOW,
+    password: str = "",
+) -> bytes:
+    """Convert a PDF document into a target document format (DOCX, PPTX, ODT, ODP, TXT).
+
+    Args:
+        input_path: File path, Path object, or raw PDF bytes.
+        output_format: Target format ('docx', 'pptx', 'odt', 'odp', 'txt'). Defaults to 'docx'.
+        output_path: Optional file path to write output. If None, output is only returned as bytes.
+        mode: Layout mode, either ConversionMode.FLOW / 'flow' or ConversionMode.CANVAS / 'canvas'.
+        password: Optional password if the PDF document is encrypted.
+
+    Returns:
+        bytes: Converted document binary payload (ZIP archive for DOCX/PPTX/ODT/ODP, UTF-8 for TXT).
+
+    Raises:
+        UnsupportedFormatError: If the requested output format is not supported.
+        ValueError: If mode is not 'flow' or 'canvas'.
+        AnyConvertError: If parsing, layout, or serialization fails.
+    """
+    conv_mode = _resolve_conversion_mode(mode)
+    emitter = _get_emitter(output_format)
+
+    doc_ir = pdf_to_document_ir(input_path, password=password, mode=conv_mode)
+    result_bytes = emitter.emit(doc_ir, mode=conv_mode)
+
+    if output_path is not None:
+        target_path = pathlib.Path(output_path)
+        target_path.parent.mkdir(parents=True, exist_ok=True)
+        target_path.write_bytes(result_bytes)
+
+    return result_bytes
+
+
+def convert_bytes(
+    pdf_bytes: Union[bytes, bytearray, memoryview],
+    output_format: str = "docx",
+    mode: Union[ConversionMode, str] = ConversionMode.FLOW,
+    password: str = "",
+) -> bytes:
+    """Convert raw in-memory PDF bytes into target format bytes.
+
+    Args:
+        pdf_bytes: Raw bytes of the PDF file.
+        output_format: Target format ('docx', 'pptx', 'odt', 'odp', 'txt').
+        mode: Layout mode ('flow' or 'canvas').
+        password: Optional password if the PDF document is encrypted.
+
+    Returns:
+        bytes: Converted document binary payload.
+    """
+    return convert(
+        input_path=pdf_bytes,
+        output_format=output_format,
+        output_path=None,
+        mode=mode,
+        password=password,
+    )
+
+
+__all__ = [
+    "SUPPORTED_FORMATS",
+    "ConversionMode",
+    "convert",
+    "convert_bytes",
+    "pdf_to_document_ir",
+]

anyconvert/cli.py

@@ -0,0 +1,134 @@
+"""Command Line Interface (CLI) entrypoint for anyconvert."""
+
+from __future__ import annotations
+
+import argparse
+import pathlib
+import sys
+from typing import Sequence
+
+
+def create_parser() -> argparse.ArgumentParser:
+    """Create and configure the command-line argument parser.
+
+    Returns:
+        argparse.ArgumentParser: Configured argument parser instance.
+    """
+    from anyconvert import __version__
+
+    parser = argparse.ArgumentParser(
+        prog="anyconvert",
+        description=(
+            "anyconvert: Pure-Python enterprise-grade document conversion engine.\n"
+            "Converts PDF documents into DOCX, PPTX, ODT, ODP, and TXT."
+        ),
+        formatter_class=argparse.ArgumentDefaultsHelpFormatter,
+    )
+
+    parser.add_argument(
+        "input",
+        nargs="?",
+        help="Path to the input PDF file to convert.",
+    )
+    parser.add_argument(
+        "-f",
+        "--format",
+        choices=["docx", "pptx", "odt", "odp", "txt"],
+        default="docx",
+        help="Target document format.",
+    )
+    parser.add_argument(
+        "-o",
+        "--output",
+        help="Path to save the converted output file. Defaults to input base name with target extension.",
+    )
+    parser.add_argument(
+        "-m",
+        "--mode",
+        choices=["flow", "canvas"],
+        default="flow",
+        help="Conversion layout mode: 'flow' (semantic reflowable) or 'canvas' (fixed absolute coordinates).",
+    )
+    parser.add_argument(
+        "-p",
+        "--password",
+        default="",
+        help="Decryption password if the PDF is password-protected.",
+    )
+    parser.add_argument(
+        "-v",
+        "--verbose",
+        action="store_true",
+        help="Enable verbose diagnostic output.",
+    )
+    parser.add_argument(
+        "--version",
+        action="version",
+        version=f"%(prog)s {__version__}",
+        help="Show program version and exit.",
+    )
+
+    return parser
+
+
+def main(argv: Sequence[str] | None = None) -> int:
+    """CLI execution entrypoint.
+
+    Args:
+        argv: Optional list of command-line arguments. If None, uses sys.argv[1:].
+
+    Returns:
+        int: Exit status code (0 for success, non-zero for error).
+    """
+    parser = create_parser()
+    args = parser.parse_args(argv)
+
+    if not args.input:
+        parser.print_help(sys.stderr)
+        return 1
+
+    input_path = pathlib.Path(args.input)
+    if not input_path.exists():
+        sys.stderr.write(f"Error: Input file '{args.input}' not found.\n")
+        return 1
+
+    # Determine output path
+    if args.output:
+        output_path = pathlib.Path(args.output)
+    else:
+        output_path = input_path.with_suffix(f".{args.format.lower()}")
+
+    if args.verbose:
+        sys.stderr.write(
+            f"[anyconvert] Input: {input_path}, Output: {output_path}, "
+            f"Format: {args.format}, Mode: {args.mode}\n"
+        )
+
+    try:
+        from anyconvert.api import convert
+        from anyconvert.exceptions import AnyConvertError
+
+        res_bytes = convert(
+            input_path=input_path,
+            output_format=args.format,
+            output_path=output_path,
+            mode=args.mode,
+            password=args.password,
+        )
+
+        if args.verbose:
+            sys.stderr.write(
+                f"[anyconvert] Successfully converted {len(res_bytes)} bytes to '{output_path}'.\n"
+            )
+        return 0
+
+    except AnyConvertError as err:
+        sys.stderr.write(f"Conversion error: {err}\n")
+        return 1
+    except Exception as err:
+        sys.stderr.write(f"Error: {err}\n")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

anyconvert/common/__init__.py

@@ -0,0 +1,55 @@
+"""Common primitives, geometry, color models, and binary readers."""
+
+from __future__ import annotations
+
+from anyconvert.common.color import (
+    BLACK,
+    BLUE,
+    DARK_GRAY,
+    GRAY,
+    GREEN,
+    LIGHT_GRAY,
+    RED,
+    TRANSPARENT,
+    WHITE,
+    Color,
+)
+from anyconvert.common.geometry import (
+    BoundingBox,
+    Matrix3x3,
+    Point,
+    Size,
+)
+from anyconvert.common.logging import (
+    configure_logging,
+    get_logger,
+)
+from anyconvert.common.reader import (
+    PDF_DELIMITERS,
+    PDF_WHITESPACE,
+    BitReader,
+    ByteReader,
+)
+
+__all__ = [
+    "Point",
+    "Size",
+    "BoundingBox",
+    "Matrix3x3",
+    "Color",
+    "BLACK",
+    "WHITE",
+    "TRANSPARENT",
+    "RED",
+    "GREEN",
+    "BLUE",
+    "GRAY",
+    "LIGHT_GRAY",
+    "DARK_GRAY",
+    "get_logger",
+    "configure_logging",
+    "ByteReader",
+    "BitReader",
+    "PDF_WHITESPACE",
+    "PDF_DELIMITERS",
+]