pdf-invoke 0.1.0__tar.gz

pdf_invoke-0.1.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) [2026] [Luciano Bermudez]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pdf_invoke-0.1.0/PKG-INFO

@@ -0,0 +1,24 @@
+Metadata-Version: 2.4
+Name: pdf-invoke
+Version: 0.1.0
+Summary: A LLM utility for working with pdfs
+License-Expression: MIT
+License-File: LICENSE
+Author: Luciano Bermudez
+Author-email: lberm007@ucr.edu
+Requires-Python: >=3.10,<4.0.0
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Dist: dotenv (>=0.9.9,<0.10.0)
+Requires-Dist: langchain (>=1.2.10,<2.0.0)
+Requires-Dist: langchain-core (>=1.2.11,<2.0.0)
+Requires-Dist: pillow (>=12.1.1,<13.0.0)
+Requires-Dist: pydantic (>=2.12.5,<3.0.0)
+Requires-Dist: pymupdf (>=1.27.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+# A package

pdf_invoke-0.1.0/README.md

@@ -0,0 +1 @@
+# A package

pdf_invoke-0.1.0/pyproject.toml

@@ -0,0 +1,29 @@
+[project]
+name = "pdf-invoke"
+version = "0.1.0"
+description = "A LLM utility for working with pdfs"
+authors = [
+    {name = "Luciano Bermudez",email = "lberm007@ucr.edu"}
+]
+readme = "README.md"
+requires-python = ">=3.10,<4.0.0"
+dependencies = [
+    "langchain-core (>=1.2.11,<2.0.0)",
+    "pydantic (>=2.12.5,<3.0.0)",
+    "pymupdf (>=1.27.1,<2.0.0)",
+    "pillow (>=12.1.1,<13.0.0)",
+    "langchain (>=1.2.10,<2.0.0)",
+    "dotenv (>=0.9.9,<0.10.0)"
+]
+license = "MIT"
+license-files = ["LICEN[CS]E*"]
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "pytest (>=9.0.2,<10.0.0)",
+    "langchain-openai (>=1.1.9,<2.0.0)"
+]

pdf_invoke-0.1.0/src/pdf_invoke/__init__.py

@@ -0,0 +1,2 @@
+from .multimodal_llm import MultiModalLLM, BaseOutput
+from .converter import PDFImageConverter

pdf_invoke-0.1.0/src/pdf_invoke/converter.py

@@ -0,0 +1,121 @@
+from pathlib import Path
+from typing import Iterable, List
+
+import pymupdf
+
+from pdf_invoke.types import ImageExt, PDFInput
+from pdf_invoke.utils import get_image_type, is_pdf_bytes, validate_image_bytes
+
+
+class PDFImageConverter:
+    def pdf_to_images(
+        self, pdf: PDFInput, zoom: float = 0.2, ext: ImageExt = "png"
+    ) -> List[bytes]:
+        doc = None
+        try:
+            if isinstance(pdf, (bytes, bytearray, memoryview)):
+                pdf_bytes = bytes(pdf)
+                self._validate_pdf_bytes(pdf_bytes)
+                doc = pymupdf.open(stream=pdf, filetype="pdf")
+
+            elif isinstance(pdf, (Path, str)):
+                doc = pymupdf.open(Path(pdf).as_posix())
+            else:
+                raise TypeError("PDF is not of expected type")
+            assert doc
+            pass
+        except Exception as e:
+            raise ValueError(f"Failed to open pdf {e}")
+
+        matrix = pymupdf.Matrix(zoom, zoom)
+        image_bytes = [page.get_pixmap(matrix=matrix).tobytes(ext) for page in doc]
+        doc.close()
+        return image_bytes
+
+    def images_to_pdf(
+        self, images: Iterable[bytes], allowed_formats=["png", "jpeg"]
+    ) -> bytes:
+        validate_image_bytes(images, allowed_formats)
+        doc = pymupdf.open()
+        for img_bytes in images:
+            img_doc = pymupdf.open(stream=img_bytes, filetype=get_image_type(img_bytes))
+            rect = img_doc[0].rect
+            page = doc.new_page(width=rect.width, height=rect.height)
+            page.insert_image(rect, stream=img_bytes)
+            img_doc.close()
+        pdf_bytes = doc.tobytes()
+        # Should be bytes either way but just to make sure
+        self._validate_pdf_bytes(pdf_bytes)
+        doc.close()
+        return pdf_bytes
+
+    def save_pdf_to_images(
+        self,
+        pdf: PDFInput,
+        output_path: str | Path,
+        pdf_name: str | None = None,
+        ext: ImageExt = "png",
+        start: int = 0,
+    ) -> str:
+        pdf_name = self._validate_pdf_name(pdf, pdf_name)
+        output_path = self._validate_path(output_path)
+        data = self.pdf_to_images(pdf)
+        for i, b in enumerate(data, start=start):
+    
+            out = output_path / f"{pdf_name}_page_{i}.{ext}"
+            out.write_bytes(b)
+        return output_path.as_posix()
+
+    def save_images_to_pdf(
+        self,
+        images: Iterable[bytes],
+        output_path: str | Path,
+        pdf_name: str,
+    ) -> str:
+        pdf_name = self._validate_pdf_name(name=pdf_name)
+        output_path = self._validate_path(output_path)
+        pdf_path = output_path / pdf_name
+
+        if pdf_path.suffix.lower() != ".pdf":
+            pdf_path = pdf_path.with_suffix(".pdf")
+
+        pdf_bytes = self.images_to_pdf(images)
+
+        pdf_path.write_bytes(pdf_bytes)
+        return pdf_path.as_posix()
+
+    def _validate_pdf_name(
+        self,
+        pdf: PDFInput | None = None,
+        name: str | None = None,
+    ) -> str:
+
+        if name is not None:
+            return name
+
+        if isinstance(pdf, (str, Path)):
+            return Path(pdf).stem
+
+        raise ValueError(
+            "Unable to determine PDF name. "
+            "Provide either a file path (str or Path) or explicitly pass `name` "
+            "when supplying raw PDF bytes."
+        )
+
+    def _validate_pdf_bytes(self, data):
+        if not is_pdf_bytes(data):
+            raise ValueError("Document is not pdf")
+
+    def _validate_path(self, path: str | Path) -> Path:
+        path = Path(path)
+        if not path.exists():
+            raise ValueError(f"Failed to validate pdf {path} cannot be resolved")
+        return path
+
+
+if __name__ == "__main__":
+    print("Test")
+    path = Path(r"pdf_invoke\data\Lecture_02_03.pdf")
+    image = Path(r"pdf_invoke\data\images\Lecture_02_03_page_1.png").read_bytes()
+    print(image[:10])
+    print(get_image_type(image))

pdf_invoke-0.1.0/src/pdf_invoke/multimodal_llm.py

@@ -0,0 +1,120 @@
+from base64 import b64encode
+from typing import Iterable, Optional, Sequence, Type
+from pathlib import Path
+from langchain_core.language_models.chat_models import BaseChatModel
+from pydantic import BaseModel
+
+from pdf_invoke.converter import PDFImageConverter
+from pdf_invoke.types import PDFInput, ALLOWED_MIME, ImageInput
+from pdf_invoke.utils import validate_image_bytes
+
+
+class BaseOutput(BaseModel):
+    data: str
+
+
+class MultiModalLLM:
+    def __init__(
+        self,
+        *,
+        prompt: str,
+        model: BaseChatModel,
+    ):
+        # Base configuration
+        self.prompt = prompt
+        self.llm = model
+
+    def _validate_input(
+        self,
+        pdf: PDFInput | None = None,
+        images: Sequence[ImageInput] | None = None,
+    ) -> Sequence[bytes]:
+        # Ensure values are okay
+        if pdf is None and images is None:
+            raise ValueError("Either pdfinput or image_bytes must be provided")
+        if pdf is not None and images is not None:
+            raise ValueError("Provide only one of pdfinput or image_bytes")
+
+        # Return
+        if pdf:
+            return PDFImageConverter().pdf_to_images(pdf)
+        elif images:
+            return [self._image_to_bytes(i) for i in images]
+        else:
+            raise RuntimeError("Unexpected Error Occured ")
+
+    def invoke(
+        self,
+        pdf: PDFInput | None = None,
+        images: Sequence[ImageInput] | None = None,
+        output_model: Optional[Type[BaseModel]] = BaseOutput,
+        mime: ALLOWED_MIME = "image/png",
+    ):
+        image_bytes = self._validate_input(pdf, images)
+        try:
+            message = self.prepare_payload(image_bytes, mime)
+            if output_model:
+                chain = self.llm.with_structured_output(schema=output_model)
+                return chain.invoke([message])
+            else:
+                return self.llm.invoke([message])
+        except Exception as e:
+            raise RuntimeError(f"Failed to invoke model {e}")
+
+    async def ainvoke(
+        self,
+        pdf: PDFInput | None = None,
+        images: Sequence[ImageInput] | None = None,
+        output_model: Optional[Type[BaseModel]] = BaseOutput,
+        mime: ALLOWED_MIME = "image/png",
+    ):
+        image_bytes = self._validate_input(pdf, images)
+        message = self.prepare_payload(image_bytes, mime)
+        if output_model:
+            chain = self.llm.with_structured_output(
+                schema=output_model,
+            )
+            return chain.ainvoke([message])
+        else:
+            return self.llm.ainvoke([message])
+
+    def prepare_payload(self, data: Sequence[bytes], mime: ALLOWED_MIME = "image/png"):
+        try:
+            image_payload = self.prepare_image_payload(data, mime=mime)
+            message = {
+                "role": "user",
+                "content": [{"type": "text", "text": self.prompt}, *image_payload],
+            }
+            return message
+        except Exception as e:
+            raise RuntimeError(f"Failed to prepare payload for LLM. Error:  {e}")
+
+    def prepare_image_payload(
+        self,
+        payload: Iterable[bytes],
+        mime: ALLOWED_MIME = "image/png",
+    ):
+        allowed_format = mime.split("/")[-1]
+        validate_image_bytes(payload, allowed_formats=set([allowed_format]))
+        return [
+            {
+                "type": "image_url",
+                "image_url": {
+                    "url": f"data:{mime};base64,{b64encode(p).decode("utf-8")}"
+                },
+            }
+            for p in payload
+        ]
+
+    def _image_to_bytes(self, image: ImageInput) -> bytes:
+        try:
+            if isinstance(image, (bytes, memoryview)):
+                return image
+            elif isinstance(image, (str | Path)):
+                return Path(image).read_bytes()
+            else:
+                raise TypeError(
+                    f"Failed to conver image to bytes received incorrect type image is of type {type(image)}"
+                )
+        except Exception as e:
+            raise ValueError(f"Failed to convert image to bytes {e}")

pdf_invoke-0.1.0/src/pdf_invoke/types.py

@@ -0,0 +1,9 @@
+from pathlib import Path
+from typing import Literal, Iterable
+
+
+PDFInput = str | Path | bytes
+ImageInput = str | Path | bytes
+ImageBytes = bytes
+ImageExt = Literal["png", "jpeg"]
+ALLOWED_MIME = Literal["image/jpeg", "image/png"]

pdf_invoke-0.1.0/src/pdf_invoke/utils.py

@@ -0,0 +1,33 @@
+from PIL import Image
+import io
+from typing import Iterable, List
+
+
+def is_pdf_bytes(data: bytes) -> bool:
+    return data.startswith(b"%PDF-")
+
+
+def get_image_type(image_bytes: bytes) -> str:
+    try:
+        with Image.open(io.BytesIO(image_bytes)) as img:
+            assert img.format
+            return img.format  # e.g., 'PNG', 'JPEG'
+    except Exception:
+        raise ValueError("Provided bytes are not a valid image.")
+
+
+def validate_image_bytes(
+    images: Iterable[bytes],
+    allowed_formats: set[str] | None = None,
+) -> List[str]:
+    formats = []
+    for idx, img_bytes in enumerate(images):
+        try:
+            fmt = get_image_type(img_bytes)
+
+            if allowed_formats and fmt.lower() not in allowed_formats:
+                raise ValueError(f"Image at index {idx} has unsupported format: {fmt}")
+            formats.append(fmt)
+        except Exception as e:
+            raise ValueError(f"Invalid image at index {idx}: {e}") from e
+    return formats