edocapi 0.0.2__py3-none-any.whl

edocapi/processors/docx.py

@@ -0,0 +1,112 @@
+"""DOCX processor for eDocAPI (uses python-docx + weasyprint for PDF)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from docx import Document as DocxDocument
+
+from edocapi.exceptions import ConversionError, InvalidDocument
+from edocapi.processors.base import BaseProcessor, register_processor
+from edocapi.storage.temporary import TemporaryStorage
+
+logger = logging.getLogger("edocapi.processors.docx")
+
+
+@register_processor("docx")
+class DOCXProcessor(BaseProcessor):
+    """Processor for Microsoft Word (.docx) documents."""
+
+    supported_input_types = {"docx"}
+    supported_output_types = {"pdf", "txt", "html"}
+
+    def __init__(self, path: Path, *, temp_storage: Any = None) -> None:
+        super().__init__(path, temp_storage=temp_storage)
+        try:
+            self._doc = DocxDocument(str(path))
+        except Exception as exc:
+            raise InvalidDocument(f"Invalid or corrupted DOCX: {exc}") from exc
+
+    def to_text(self) -> str:
+        """Extract all paragraph text."""
+        paragraphs = [p.text for p in self._doc.paragraphs if p.text.strip()]
+        # Also extract tables
+        for table in self._doc.tables:
+            for row in table.rows:
+                cells = [cell.text.strip() for cell in row.cells]
+                paragraphs.append("\t".join(cells))
+        return "\n".join(paragraphs)
+
+    def to_html(self) -> str:
+        """Convert DOCX to a simple HTML representation."""
+        parts: list[str] = ["<html><body>"]
+        for p in self._doc.paragraphs:
+            style = p.style.name.lower() if p.style else ""
+            text = (
+                p.text.replace("&", "&amp;")
+                .replace("<", "&lt;")
+                .replace(">", "&gt;")
+            )
+            if not text.strip():
+                continue
+            if "heading 1" in style:
+                parts.append(f"<h1>{text}</h1>")
+            elif "heading 2" in style:
+                parts.append(f"<h2>{text}</h2>")
+            elif "heading 3" in style:
+                parts.append(f"<h3>{text}</h3>")
+            else:
+                parts.append(f"<p>{text}</p>")
+
+        for table in self._doc.tables:
+            parts.append("<table border='1'>")
+            for row in table.rows:
+                parts.append("<tr>")
+                for cell in row.cells:
+                    cell_text = (
+                        cell.text.replace("&", "&amp;")
+                        .replace("<", "&lt;")
+                        .replace(">", "&gt;")
+                    )
+                    parts.append(f"<td>{cell_text}</td>")
+                parts.append("</tr>")
+            parts.append("</table>")
+
+        parts.append("</body></html>")
+        return "\n".join(parts)
+
+    def to_pdf(self) -> Path:
+        """Convert DOCX -> HTML -> PDF via WeasyPrint."""
+        html = self.to_html()
+        try:
+            from weasyprint import HTML
+        except ImportError as exc:
+            raise ConversionError(
+                "DOCX -> PDF requires weasyprint. "
+                "Install with: pip install edocapi[html]",
+                source="docx",
+                target="pdf",
+            ) from exc
+
+        storage = self.temp_storage or TemporaryStorage()
+        out = storage.create_file(suffix=".pdf", prefix="docx_")
+        HTML(string=html).write_pdf(str(out))
+        return out
+
+    def info(self) -> dict[str, Any]:
+        core = self._doc.core_properties
+        return {
+            "filename": self.path.name,
+            "type": "docx",
+            "size": self.path.stat().st_size,
+            "extension": ".docx",
+            "title": core.title or None,
+            "author": core.author or None,
+            "subject": core.subject or None,
+            "created": str(core.created) if core.created else None,
+            "modified": str(core.modified) if core.modified else None,
+            "paragraphs": len(self._doc.paragraphs),
+            "tables": len(self._doc.tables),
+        }

edocapi/processors/html.py

@@ -0,0 +1,64 @@
+"""HTML processor for eDocAPI (uses weasyprint for PDF)."""
+
+from __future__ import annotations
+
+import logging
+import re
+from pathlib import Path
+from typing import Any
+
+from edocapi.exceptions import ConversionError
+from edocapi.processors.base import BaseProcessor, register_processor
+from edocapi.storage.temporary import TemporaryStorage
+
+logger = logging.getLogger("edocapi.processors.html")
+
+
+@register_processor("html")
+class HTMLProcessor(BaseProcessor):
+    """Processor for HTML documents."""
+
+    supported_input_types = {"html"}
+    supported_output_types = {"pdf", "txt", "html"}
+
+    def to_text(self) -> str:
+        """Strip tags and return approximate plain text."""
+        content = self.path.read_text(encoding="utf-8", errors="replace")
+        # Very simple tag stripping
+        text = re.sub(r"<script[^>]*>.*?</script>", "", content, flags=re.DOTALL | re.I)
+        text = re.sub(r"<style[^>]*>.*?</style>", "", text, flags=re.DOTALL | re.I)
+        text = re.sub(r"<[^>]+>", " ", text)
+        text = re.sub(r"\s+", " ", text)
+        return text.strip()
+
+    def to_html(self) -> str:
+        return self.path.read_text(encoding="utf-8", errors="replace")
+
+    def to_pdf(self) -> Path:
+        """Convert HTML to PDF using WeasyPrint."""
+        try:
+            from weasyprint import HTML
+        except ImportError as exc:
+            raise ConversionError(
+                "HTML -> PDF requires weasyprint. "
+                "Install with: pip install edocapi[html]",
+                source="html",
+                target="pdf",
+            ) from exc
+
+        storage = self.temp_storage or TemporaryStorage()
+        out = storage.create_file(suffix=".pdf", prefix="html_")
+        HTML(filename=str(self.path)).write_pdf(str(out))
+        return out
+
+    def info(self) -> dict[str, Any]:
+        content = self.path.read_text(encoding="utf-8", errors="replace")
+        title_match = re.search(r"<title[^>]*>(.*?)</title>", content, re.I | re.DOTALL)
+        title = title_match.group(1).strip() if title_match else None
+        return {
+            "filename": self.path.name,
+            "type": "html",
+            "size": self.path.stat().st_size,
+            "extension": self.path.suffix.lower(),
+            "title": title,
+        }

edocapi/processors/image.py

@@ -0,0 +1,80 @@
+"""Image processor for eDocAPI (uses Pillow + weasyprint / reportlab-like via PDF)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+from PIL import Image
+
+from edocapi.exceptions import ConversionError, InvalidDocument
+from edocapi.processors.base import BaseProcessor, register_processor
+from edocapi.storage.temporary import TemporaryStorage
+
+logger = logging.getLogger("edocapi.processors.image")
+
+
+@register_processor("jpeg", "jpg", "png", "webp")
+class ImageProcessor(BaseProcessor):
+    """Processor for common image formats."""
+
+    supported_input_types = {"jpeg", "jpg", "png", "webp"}
+    supported_output_types = {"pdf", "png", "jpg", "webp"}
+
+    def __init__(self, path: Path, *, temp_storage: Any = None) -> None:
+        super().__init__(path, temp_storage=temp_storage)
+        try:
+            self._img = Image.open(str(path))
+            self._img.load()  # force load to validate
+        except Exception as exc:
+            raise InvalidDocument(f"Invalid or corrupted image: {exc}") from exc
+
+    def to_pdf(self) -> Path:
+        """Convert image to a single-page PDF."""
+        storage = self.temp_storage or TemporaryStorage()
+        out = storage.create_file(suffix=".pdf", prefix="img_")
+
+        # Convert to RGB if necessary (PDF does not support all modes)
+        img = self._img
+        if img.mode in ("RGBA", "P", "LA"):
+            background = Image.new("RGB", img.size, (255, 255, 255))
+            if img.mode == "P":
+                img = img.convert("RGBA")
+            background.paste(img, mask=img.split()[-1] if img.mode in ("RGBA", "LA") else None)
+            img = background
+        elif img.mode != "RGB":
+            img = img.convert("RGB")
+
+        img.save(str(out), "PDF", resolution=100.0)
+        return out
+
+    def to_text(self) -> str:
+        raise NotImplementedError(
+            "Text extraction from images requires OCR, which is not available in v0.0.2."
+        )
+
+    def to_images(self, *, format: str = "png") -> list[Path]:
+        """Return a copy of the image in the requested format."""
+        fmt = format.lower().lstrip(".")
+        if fmt not in {"png", "jpg", "jpeg", "webp"}:
+            raise ConversionError(f"Unsupported image format: {format}")
+
+        storage = self.temp_storage or TemporaryStorage()
+        suffix = f".{fmt if fmt != 'jpeg' else 'jpg'}"
+        out = storage.create_file(suffix=suffix, prefix="img_")
+        save_fmt = "JPEG" if fmt in ("jpg", "jpeg") else fmt.upper()
+        self._img.save(str(out), save_fmt)
+        return [out]
+
+    def info(self) -> dict[str, Any]:
+        return {
+            "filename": self.path.name,
+            "type": self.path.suffix.lstrip(".").lower(),
+            "size": self.path.stat().st_size,
+            "extension": self.path.suffix.lower(),
+            "width": self._img.width,
+            "height": self._img.height,
+            "mode": self._img.mode,
+            "format": self._img.format,
+        }

edocapi/processors/markdown.py

@@ -0,0 +1,64 @@
+"""Markdown processor for eDocAPI."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any
+
+import markdown
+
+from edocapi.exceptions import ConversionError
+from edocapi.processors.base import BaseProcessor, register_processor
+from edocapi.storage.temporary import TemporaryStorage
+
+logger = logging.getLogger("edocapi.processors.markdown")
+
+
+@register_processor("markdown", "md")
+class MarkdownProcessor(BaseProcessor):
+    """Processor for Markdown documents."""
+
+    supported_input_types = {"markdown", "md"}
+    supported_output_types = {"pdf", "html", "txt"}
+
+    def to_text(self) -> str:
+        """Return the raw Markdown (or strip to plain text)."""
+        return self.path.read_text(encoding="utf-8", errors="replace")
+
+    def to_html(self) -> str:
+        """Convert Markdown to HTML using the markdown library."""
+        md = self.path.read_text(encoding="utf-8", errors="replace")
+        html_body = markdown.markdown(
+            md,
+            extensions=["extra", "codehilite", "tables", "fenced_code"],
+        )
+        return f"<!DOCTYPE html><html><body>{html_body}</body></html>"
+
+    def to_pdf(self) -> Path:
+        """Markdown -> HTML -> PDF."""
+        html = self.to_html()
+        try:
+            from weasyprint import HTML
+        except ImportError as exc:
+            raise ConversionError(
+                "Markdown -> PDF requires weasyprint. "
+                "Install with: pip install edocapi[html]",
+                source="markdown",
+                target="pdf",
+            ) from exc
+
+        storage = self.temp_storage or TemporaryStorage()
+        out = storage.create_file(suffix=".pdf", prefix="md_")
+        HTML(string=html).write_pdf(str(out))
+        return out
+
+    def info(self) -> dict[str, Any]:
+        content = self.path.read_text(encoding="utf-8", errors="replace")
+        return {
+            "filename": self.path.name,
+            "type": "markdown",
+            "size": self.path.stat().st_size,
+            "extension": self.path.suffix.lower(),
+            "lines": content.count("\n") + 1,
+        }

edocapi/processors/pdf.py

@@ -0,0 +1,231 @@
+"""PDF processor for eDocAPI (uses pypdf)."""
+
+from __future__ import annotations
+
+import logging
+from pathlib import Path
+from typing import Any, Sequence
+
+from pypdf import PdfReader, PdfWriter
+from pypdf.errors import PdfReadError
+
+from edocapi.exceptions import InvalidDocument, ProcessingError
+from edocapi.processors.base import BaseProcessor, register_processor
+from edocapi.storage.temporary import TemporaryStorage
+
+logger = logging.getLogger("edocapi.processors.pdf")
+
+
+@register_processor("pdf")
+class PDFProcessor(BaseProcessor):
+    """Processor for PDF documents."""
+
+    supported_input_types = {"pdf"}
+    supported_output_types = {"pdf", "txt", "html", "png", "jpg", "webp"}
+
+    def __init__(self, path: Path, *, temp_storage: Any = None) -> None:
+        super().__init__(path, temp_storage=temp_storage)
+        try:
+            self._reader = PdfReader(str(path))
+        except PdfReadError as exc:
+            raise InvalidDocument(f"Invalid or corrupted PDF: {exc}") from exc
+
+    # ------------------------------------------------------------------
+    # Basic conversions
+    # ------------------------------------------------------------------
+
+    def to_pdf(self) -> Path:
+        """Return a copy of the PDF (identity conversion)."""
+        out = self._temp_path(suffix=".pdf", prefix="copy_")
+        writer = PdfWriter()
+        for page in self._reader.pages:
+            writer.add_page(page)
+        with out.open("wb") as f:
+            writer.write(f)
+        return out
+
+    def to_text(self) -> str:
+        """Extract text from all pages."""
+        parts: list[str] = []
+        for i, page in enumerate(self._reader.pages, start=1):
+            text = page.extract_text() or ""
+            if text.strip():
+                parts.append(f"--- Page {i} ---\n{text.strip()}")
+        return "\n\n".join(parts)
+
+    def to_html(self) -> str:
+        """Simple HTML representation of extracted text."""
+        text = self.to_text()
+        # Very basic wrapping  not a full visual conversion
+        escaped = (
+            text.replace("&", "&")
+            .replace("<", "&lt;")
+            .replace(">", "&gt;")
+            .replace("\n", "<br>\n")
+        )
+        return f"<html><body><pre>{escaped}</pre></body></html>"
+
+    def to_images(self, *, format: str = "png") -> list[Path]:
+        """Convert PDF pages to images.
+
+        Requires the optional `pdf2image` package (and poppler).
+        If unavailable, raises a clear ProcessingError.
+        """
+        try:
+            from pdf2image import convert_from_path
+        except ImportError as exc:
+            raise ProcessingError(
+                "PDF -> images requires the optional dependency 'pdf2image' "
+                "and the system package 'poppler'. "
+                "Install with: pip install pdf2image"
+            ) from exc
+
+        fmt = format.lower().lstrip(".")
+        if fmt not in {"png", "jpg", "jpeg", "webp"}:
+            raise ProcessingError(f"Unsupported image format: {format}")
+
+        images = convert_from_path(str(self.path))
+        paths: list[Path] = []
+        for i, img in enumerate(images, start=1):
+            suffix = f".{fmt if fmt != 'jpeg' else 'jpg'}"
+            out = self._temp_path(suffix=suffix, prefix=f"page_{i}_")
+            img.save(str(out), fmt.upper() if fmt != "jpg" else "JPEG")
+            paths.append(out)
+        return paths
+
+    def info(self) -> dict[str, Any]:
+        meta = self._reader.metadata or {}
+        return {
+            "filename": self.path.name,
+            "type": "pdf",
+            "pages": len(self._reader.pages),
+            "size": self.path.stat().st_size,
+            "extension": ".pdf",
+            "title": getattr(meta, "title", None) or meta.get("/Title"),
+            "author": getattr(meta, "author", None) or meta.get("/Author"),
+            "subject": getattr(meta, "subject", None) or meta.get("/Subject"),
+            "creator": getattr(meta, "creator", None) or meta.get("/Creator"),
+            "producer": getattr(meta, "producer", None) or meta.get("/Producer"),
+            "creation_date": str(getattr(meta, "creation_date", None) or meta.get("/CreationDate") or ""),
+            "modification_date": str(getattr(meta, "modification_date", None) or meta.get("/ModDate") or ""),
+        }
+
+    # ------------------------------------------------------------------
+    # PDF operations
+    # ------------------------------------------------------------------
+
+    def compress(self, level: str = "medium") -> Path:
+        """Compress the PDF.
+
+        Levels:
+            low     minimal compression (mostly remove unused objects)
+            medium  default, moderate image quality reduction if possible
+            high    aggressive (may reduce quality)
+
+        Note: pypdf's compression is limited; this is a best-effort implementation.
+        """
+        level = level.lower()
+        if level not in {"low", "medium", "high"}:
+            raise ProcessingError(f"Unknown compression level: {level}")
+
+        writer = PdfWriter()
+        for page in self._reader.pages:
+            # Basic content stream compression
+            page.compress_content_streams()
+            writer.add_page(page)
+
+        # Remove unused objects / metadata for higher levels
+        if level in {"medium", "high"}:
+            try:
+                writer.compress_identical_objects(
+                    remove_duplicates=True, remove_unreferenced=True
+                )
+            except TypeError:
+                # older pypdf API
+                writer.compress_identical_objects(
+                    remove_identicals=True, remove_orphans=True
+                )
+
+        out = self._temp_path(suffix=".pdf", prefix="compressed_")
+        with out.open("wb") as f:
+            writer.write(f)
+        return out
+
+    def split(self) -> list[Path]:
+        """Split into one PDF per page."""
+        paths: list[Path] = []
+        for i, page in enumerate(self._reader.pages, start=1):
+            writer = PdfWriter()
+            writer.add_page(page)
+            out = self._temp_path(suffix=".pdf", prefix=f"page_{i}_")
+            with out.open("wb") as f:
+                writer.write(f)
+            paths.append(out)
+        return paths
+
+    def extract_pages(self, start: int, end: int | None = None) -> Path:
+        """Extract pages start..end (1-based inclusive)."""
+        total = len(self._reader.pages)
+        if start < 1 or start > total:
+            raise ProcessingError(f"Start page {start} out of range (1-{total}).")
+        if end is None:
+            end = total
+        if end < start or end > total:
+            raise ProcessingError(f"End page {end} out of range ({start}-{total}).")
+
+        writer = PdfWriter()
+        for i in range(start - 1, end):  # convert to 0-based
+            writer.add_page(self._reader.pages[i])
+
+        out = self._temp_path(
+            suffix=".pdf",
+            prefix=f"pages_{start}-{end}_",
+        )
+        with out.open("wb") as f:
+            writer.write(f)
+        return out
+
+    def rotate(self, degrees: int = 90, pages: Sequence[int] | None = None) -> Path:
+        """Rotate pages by degrees (90, 180, 270). pages is 1-based."""
+        if degrees % 90 != 0:
+            raise ProcessingError("Rotation must be a multiple of 90 degrees.")
+
+        writer = PdfWriter()
+        total = len(self._reader.pages)
+        page_set = set(pages) if pages else None
+
+        for i, page in enumerate(self._reader.pages, start=1):
+            if page_set is None or i in page_set:
+                page.rotate(degrees)
+            writer.add_page(page)
+
+        out = self._temp_path(suffix=".pdf", prefix="rotated_")
+        with out.open("wb") as f:
+            writer.write(f)
+        return out
+
+    # ------------------------------------------------------------------
+    # Helpers
+    # ------------------------------------------------------------------
+
+    def _temp_path(self, suffix: str = "", prefix: str = "pdf_") -> Path:
+        storage = self.temp_storage or TemporaryStorage()
+        return storage.create_file(suffix=suffix, prefix=prefix)
+
+    @staticmethod
+    def merge(paths: Sequence[Path], *, temp_storage: TemporaryStorage | None = None) -> Path:
+        """Merge multiple PDFs into one."""
+        writer = PdfWriter()
+        for p in paths:
+            try:
+                reader = PdfReader(str(p))
+                for page in reader.pages:
+                    writer.add_page(page)
+            except PdfReadError as exc:
+                raise InvalidDocument(f"Cannot read PDF for merge: {p.name}: {exc}") from exc
+
+        storage = temp_storage or TemporaryStorage()
+        out = storage.create_file(suffix=".pdf", prefix="merged_")
+        with out.open("wb") as f:
+            writer.write(f)
+        return out

edocapi/processors/txt.py

@@ -0,0 +1,58 @@
+"""Plain-text processor for eDocAPI."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from edocapi.processors.base import BaseProcessor, register_processor
+from edocapi.storage.temporary import TemporaryStorage
+
+
+@register_processor("txt")
+class TXTProcessor(BaseProcessor):
+    """Processor for plain-text documents."""
+
+    supported_input_types = {"txt"}
+    supported_output_types = {"txt", "html", "pdf"}
+
+    def to_text(self) -> str:
+        return self.path.read_text(encoding="utf-8", errors="replace")
+
+    def to_html(self) -> str:
+        text = (
+            self.to_text()
+            .replace("&", "&")
+            .replace("<", "&lt;")
+            .replace(">", "&gt;")
+            .replace("\n", "<br>\n")
+        )
+        return f"<html><body><pre>{text}</pre></body></html>"
+
+    def to_pdf(self) -> Path:
+        html = self.to_html()
+        try:
+            from weasyprint import HTML
+        except ImportError as exc:
+            from edocapi.exceptions import ConversionError
+            raise ConversionError(
+                "TXT -> PDF requires weasyprint. Install with: pip install edocapi[html]",
+                source="txt",
+                target="pdf",
+            ) from exc
+
+        storage = self.temp_storage or TemporaryStorage()
+        out = storage.create_file(suffix=".pdf", prefix="txt_")
+        HTML(string=html).write_pdf(str(out))
+        return out
+
+    def info(self) -> dict[str, Any]:
+        content = self.to_text()
+        return {
+            "filename": self.path.name,
+            "type": "txt",
+            "size": self.path.stat().st_size,
+            "extension": ".txt",
+            "lines": content.count("\n") + 1,
+            "characters": len(content),
+        }