pdf_segmentation 0.1.0__tar.gz

pdf_segmentation-0.1.0/PKG-INFO

@@ -0,0 +1,19 @@
+Metadata-Version: 2.4
+Name: pdf_segmentation
+Version: 0.1.0
+Summary: 
+Author: Luciano Bermudez
+Author-email: lucianobmecheng69@gmail.com
+Requires-Python: >=3.11,<4.0.0
+Classifier: Programming Language :: Python :: 3
+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: langchain (>=1.2.8,<2.0.0)
+Requires-Dist: langgraph (>=1.0.7,<2.0.0)
+Requires-Dist: pymupdf (>=1.26.7,<2.0.0)
+Requires-Dist: python-dotenv (>=1.2.1,<2.0.0)
+Description-Content-Type: text/markdown
+
+

pdf_segmentation-0.1.0/pdf_segmentation/src/annotator/__init__.py

@@ -0,0 +1 @@
+from .pdf_annotator import PDFAnnotator

pdf_segmentation-0.1.0/pdf_segmentation/src/annotator/pdf_annotator.py

@@ -0,0 +1,150 @@
+from pathlib import Path
+from typing import Literal, Optional, Tuple
+
+import pymupdf
+from pymupdf import Page
+
+from pdf_image_converter import PDFImageConverter
+from type import Anchor, AnchorPos
+
+
+class PDFAnnotator:
+    def __init__(
+        self,
+        pdf_path: str | Path,
+        anchor: Anchor | AnchorPos = Anchor.BOTTOM_LEFT,
+        margin_frac: float = 1 / 10,
+        offset: Tuple[int, int] = (10, 10),
+        zoom: float = 2.0,
+    ):
+        self.pdf = Path(pdf_path).resolve()
+        self.anchor = Anchor(anchor)
+        self.margin_frac = margin_frac
+        self.offset = offset
+        self.zoom = zoom
+        self._validate()
+
+    def annotate_and_render_pages(
+        self,
+    ) -> bytes:
+        doc = pymupdf.open(self.pdf)
+        try:
+            # Annotate all pages
+            for page in doc:
+                assert isinstance(page, Page)
+                self._annotate_page(page)
+            # Return annotated PDF as bytes
+            return doc.tobytes()
+        finally:
+            doc.close()
+
+    def _annotate_and_save(
+        self,
+        method: Literal["pdf", "image"] = "image",
+        output_path: Optional[str | Path] = None,
+    ) -> str:
+        data = self.annotate_and_render_pages()
+        output_path = self.get_output_path(path, method)
+        if method == "pdf":
+            if not isinstance(data, (bytes, bytearray)):
+                raise ValueError("Expected PDF data to be bytes")
+            output_path.write_bytes(data)
+            return output_path.as_posix()
+        elif method == "image":
+            PDFImageConverter().save_to_images(
+                data, output_path, pdf_name=self.pdf.stem
+            )
+        return output_path.as_posix()
+
+    def _annotate_page(
+        self,
+        page: Page,
+    ):
+        if page.rotation != 0:
+            page.set_rotation(0)
+
+        rect = page.rect
+        cx, cy = self._get_annotation_coords(
+            (rect.width, rect.height),
+            self.margin_frac,
+            self.offset,
+            self.anchor,
+        )
+
+        radius = rect.width * self.margin_frac
+
+        # draw circle
+        page.draw_circle(
+            center=(cx, cy),
+            radius=radius,
+        )
+
+        # draw centered number
+        box_size = radius
+        label_rect = pymupdf.Rect(
+            cx - box_size,
+            cy - box_size,
+            cx + box_size,
+            cy + box_size,
+        )
+
+        page.insert_textbox(
+            label_rect,
+            str(page.number),
+            fontsize=radius,
+            align=pymupdf.TEXT_ALIGN_CENTER,
+        )
+
+    def _get_annotation_coords(
+        self,
+        size: tuple[int, int],
+        margin_frac: float = 1 / 10,
+        offset: tuple[int, int] = (10, 10),
+        anchor: Anchor = Anchor.BOTTOM_LEFT,
+    ) -> Tuple[float, float]:
+        width, height = size
+        x_off, y_off = offset
+
+        match anchor.value:
+            case "top-left":
+                cx = width * margin_frac + x_off
+                cy = height * margin_frac + y_off
+            case "top-right":
+                cx = width - (width * margin_frac) - x_off
+                cy = height * margin_frac + y_off
+            case "bottom-left":
+                cx = width * margin_frac + x_off
+                cy = height - (height * margin_frac) - y_off
+            case "bottom-right":
+                cx = width - (width * margin_frac) - x_off
+                cy = height - (height * margin_frac) - y_off
+            case _:
+                raise ValueError(f"Invalid anchor: {anchor}")
+        return cx, cy
+
+    def get_output_path(
+        self,
+        path: Optional[str | Path] = None,
+        method: Literal["image", "pdf"] = "image",
+    ) -> Path:
+        if path:
+            return Path(path).resolve()
+        if method == "pdf":
+            output_path = self.pdf.with_name(f"{self.pdf.stem}_annotated.pdf")
+        elif method == "image":
+            output_path = self.pdf.with_name(f"{self.pdf.stem}_annotated_pages")
+            output_path.mkdir(parents=True, exist_ok=True)
+
+        return output_path
+
+    def _validate(self):
+        if not self.pdf.exists():
+            raise FileNotFoundError(f"PDF Path {self.pdf} does not exist")
+
+
+if __name__ == "__main__":
+    path = "data/Lecture_02_03.pdf"
+    output = Path(r"src\data\images").resolve()
+    PDFAnnotator(path, anchor="bottom-left", margin_frac=1 / 20)._annotate_and_save(
+        method="image"
+    )

pdf_segmentation-0.1.0/pdf_segmentation/src/graph/graph.py

@@ -0,0 +1,176 @@
+from pathlib import Path
+from typing import List, Type
+from typing import Generic, TypeVar, List
+import base64
+
+from pydantic import BaseModel, field_serializer, Field
+from langgraph.graph import StateGraph, START, END
+from langchain.chat_models import init_chat_model
+from dotenv import load_dotenv
+
+from type import PDFInput, PageRange
+from annotator.pdf_annotator import PDFAnnotator
+from pdf_llm.pdf_llm import PDFMultiModalLLM
+from pdf_seperator.pdf_seperator import PDFSeperator
+from pdf_image_converter import PDFImageConverter
+
+load_dotenv()
+
+
+class Section(BaseModel):
+    """
+    Base class for any structured unit extracted from a document.
+    This should contain ONLY semantic fields produced by the LLM.
+    """
+
+    page_range: PageRange
+
+
+T = TypeVar("T", bound=Section)
+
+
+class ListOutput(BaseModel, Generic[T]):
+    items: List[T]
+
+
+class ParsedUnit(
+    BaseModel,
+    Generic[T],
+):
+    """
+    A semantic unit enriched with pipeline-generated artifacts.
+    """
+
+    data: T
+    pdf_bytes: bytes | None = None
+
+    @field_serializer("pdf_bytes")
+    def serialize_pdf_bytes(self, value: bytes):
+        return base64.b64encode(value).decode("ascii")
+
+
+model = init_chat_model(model="gpt-4o", model_provider="openai")
+
+
+class State(BaseModel, Generic[T]):
+    # --- Inputs ---
+    pdf: str | Path
+    prompt: str
+    pdf_bytes: bytes | None = None
+
+    # --- Schema configuration ---
+    output_schema: Type[ListOutput[T]] = Field(exclude=True)
+    raw_output: List[T] = []
+
+    parsed: list[ParsedUnit[T]] = Field(default_factory=list, exclude=False)
+
+    @field_serializer("pdf_bytes")
+    def serialize_pdf_bytes(self, value: bytes):
+        return base64.b64encode(value).decode("ascii")
+
+
+def prepare_pdf(state: State):
+    state.pdf = Path(state.pdf)
+    if not state.pdf.exists():
+        raise ValueError("PDF path cannot be resolved")
+    pdf = PDFAnnotator(state.pdf).annotate_and_render_pages()
+    return {"pdf_bytes": pdf}
+
+
+def get_sections(state: State):
+    llm = PDFMultiModalLLM(
+        prompt=state.prompt,
+        pdf=state.pdf_bytes,
+        model=model,
+    )
+    result = llm.invoke(state.output_schema)
+    result = state.output_schema.model_validate(result)
+    return {"raw_output": result.items}
+
+
+def seperate_pages(state: State[T]):
+    parsed = []
+    if not state.pdf_bytes:
+        raise ValueError("PDF bytes is None")
+    separator = PDFSeperator(pdf_bytes=state.pdf_bytes)
+    for unit in state.raw_output:
+        page_range = getattr(unit, "page_range", None)
+        if page_range is None:
+            raise ValueError("Unit does not define a page_range")
+        cleaned = ParsedUnit[T](
+            data=unit,
+            pdf_bytes=separator.extract_page_range(
+                start=page_range.start_page - 1,
+                end=page_range.end_page - 1,
+            ),
+        )
+        parsed.append(cleaned)
+    return {"parsed": parsed}
+
+
+graph = StateGraph(State)
+graph.add_node(prepare_pdf)
+graph.add_node(get_sections)
+graph.add_node(seperate_pages)
+
+graph.add_edge(START, "prepare_pdf")
+graph.add_edge("prepare_pdf", "get_sections")
+graph.add_edge("get_sections", "seperate_pages")
+graph.add_edge("seperate_pages", END)
+graph = graph.compile()
+
+
+if __name__ == "__main__":
+    path = "data/Lecture_02_03.pdf"
+    from typing import Literal
+
+    class MySection(Section, BaseModel):
+        title: str
+        description: str
+        section_type: Literal["derivation", "question"]
+
+    class MySections(ListOutput[MySection]):
+        items: List[MySection]
+
+    result = graph.invoke(
+        State(
+            output_schema=MySections,
+            pdf=path,
+            prompt="""You are analyzing a set of lecture notes.
+
+Your task is to identify and extract distinct sections that fall into ONE of the following two categories only:
+
+1. **Derivation**
+   - A derivation is a mathematical development that proceeds step-by-step using equations, formulas, algebra, calculus, or symbolic manipulation.
+   - It typically starts from assumptions, definitions, or governing equations and arrives at a derived result.
+   - Only include content that is explicitly part of the mathematical derivation.
+   - Do NOT explain, summarize, or add interpretation beyond what is written.
+
+2. **Question**
+   - A question is a clearly defined problem or practice exercise posed to the reader.
+   - It may begin with phrases such as “Find”, “Determine”, “Calculate”, “Show that”, or be labeled as an example, problem, or practice question.
+   - Only include the question statement itself.
+   - Do NOT include solution steps unless they are explicitly written as part of the question.
+
+For each identified section:
+- Create a separate section entry.
+- Assign the appropriate `section_type` (`"derivation"` or `"question"`).
+- Use the section’s visible heading or a concise descriptive title.
+- Provide a short description that closely reflects the original content without adding new information.
+
+Page indexing:
+- The lecture pages are annotated with a circled page number in the bottom-left corner.
+- Use this circled page number as the authoritative reference when determining where a section begins and ends.
+
+Important constraints:
+- Do not merge multiple derivations or questions into a single section.
+- Do not invent structure that is not present in the lecture.
+- If content is ambiguous, only include it if it clearly fits one of the two categories.""",
+        )
+    )
+    result = State.model_validate(result)
+    from utils import to_serializable
+    import json
+
+    output = Path("output.json").resolve()
+    output.write_text(json.dumps(to_serializable(result)))

pdf_segmentation-0.1.0/pdf_segmentation/src/helper.py

@@ -0,0 +1,7 @@
+from pathlib import Path
+from graph.graph import State
+import json
+from utils import save_base64_image
+path = Path("output.json").resolve()
+data = State.model_validate(json.loads(path.read_text()))
+save_base64_image(data.parsed[-1].pdf_bytes, "data_output.pdf")

pdf_segmentation-0.1.0/pdf_segmentation/src/image_payload_builder.py

@@ -0,0 +1,35 @@
+from pathlib import Path
+import base64
+from typing import Sequence, List
+from type import PDFInput
+
+
+class ImagePayloadBuilder:
+    @staticmethod
+    def _to_bytes(data: PDFInput) -> bytes:
+        if isinstance(data, (bytes, bytearray, memoryview)):
+            return bytes(data)
+
+        path = Path(data)
+        if not path.exists():
+            raise FileNotFoundError(f"Image path not found: {path}")
+        return path.read_bytes()
+
+    @staticmethod
+    def encode(data: bytes) -> str:
+        return base64.b64encode(data).decode("utf-8")
+
+    @classmethod
+    def prepare_llm_payload(
+        cls,
+        payload: Sequence[PDFInput],
+        mime: str = "image/jpeg",
+    ) -> List[dict[str, str | dict[str, str]]]:
+        payload = [cls._to_bytes(p) for p in payload]
+        return [
+            {
+                "type": "image_url",
+                "image_url": {"url": f"data:{mime};base64,{cls.encode(p)}"},
+            }
+            for p in payload
+        ]

pdf_segmentation-0.1.0/pdf_segmentation/src/pdf_image_converter/__init__.py

@@ -0,0 +1 @@
+from .pdf_image_converter import PDFImageConverter

pdf_segmentation-0.1.0/pdf_segmentation/src/pdf_image_converter/pdf_image_converter.py

@@ -0,0 +1,65 @@
+from type import PDFInput, ImageExt
+import pymupdf
+from typing import List, Optional, Iterable
+from pathlib import Path
+
+
+class PDFImageConverter:
+    def convert_to_images(
+        self, pdf: PDFInput, zoom: float = 0.2, ext: ImageExt = "png"
+    ) -> List[bytes]:
+
+        try:
+            doc = None
+            if isinstance(pdf, (bytes, bytearray, memoryview)):
+                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
+        except Exception as e:
+            raise ValueError(f"Failed to open document {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 save_to_images(
+        self,
+        pdf: PDFInput,
+        output_path: str | Path,
+        pdf_name: str | None = None,
+        ext: ImageExt = "png",
+        start: int = 0,
+    ) -> None:
+
+        if pdf_name is None:
+            if isinstance(pdf, (str, Path)):
+                pdf_name = Path(pdf).stem
+            else:
+                raise ValueError("pdf_name must be provided when pdf is not a path")
+
+        output_path = self._validate(output_path)
+        data = self.convert_to_images(pdf)
+        for i, b in enumerate(data, start=start):
+            out = output_path / f"{pdf_name}_page_{i}.{ext}"
+            out.write_bytes(b)
+
+    def images_to_pdf(self, images: Iterable[bytes]) -> bytes:
+        doc = pymupdf.open()
+        for img_bytes in images:
+            img_doc = pymupdf.open(stream=img_bytes, filetype="png")
+            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()
+        doc.close()
+        return pdf_bytes
+
+    def _validate(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

pdf_segmentation-0.1.0/pdf_segmentation/src/pdf_llm/__init__.py

@@ -0,0 +1 @@
+from .pdf_llm import PDFMultiModalLLM

pdf_segmentation-0.1.0/pdf_segmentation/src/pdf_llm/pdf_llm.py

@@ -0,0 +1,89 @@
+from pathlib import Path
+from typing import Optional, Sequence, Type
+
+import pymupdf
+from pydantic import BaseModel
+from langchain_core.language_models.chat_models import BaseChatModel
+from langchain.chat_models import init_chat_model
+from type import PDFInput, BaseOutput
+from image_payload_builder import ImagePayloadBuilder
+from pdf_image_converter import PDFImageConverter
+
+
+class PDFMultiModalLLM:
+    def __init__(
+        self,
+        *,
+        prompt: str,
+        model: BaseChatModel,
+        pdf: PDFInput | None = None,
+        image_bytes: Sequence[bytes] | None = None,
+    ):
+        if pdf is None and image_bytes is None:
+            raise ValueError("Either pdf_path or image_bytes must be provided")
+        if pdf is not None and image_bytes is not None:
+            raise ValueError("Provide only one of pdf_path or image_bytes")
+
+        self.prompt = prompt
+        self.builder = ImagePayloadBuilder()
+        self.llm = model
+
+        if pdf is not None:
+            self.pdf_bytes = PDFImageConverter().convert_to_images(pdf)
+
+        elif image_bytes:
+            self.pdf_bytes = list(image_bytes)
+        else:
+            raise RuntimeError("Unexpected Error Occured ")
+
+    def prepare_payload(self, mime="image/png"):
+        try:
+            image_payload = self.builder.prepare_llm_payload(self.pdf_bytes, 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 invoke(
+        self,
+        output_model: Optional[Type[BaseModel]] = BaseOutput,
+        mime: str = "image/png",
+    ):
+        try:
+            message = self.prepare_payload(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,
+        output_model: Optional[Type[BaseModel]] = BaseOutput,
+    ):
+        message = self.prepare_payload()
+        if output_model:
+            chain = self.llm.with_structured_output(
+                schema=output_model,
+            )
+            return chain.ainvoke([message])
+        else:
+            return self.llm.ainvoke([message])
+
+
+if __name__ == "__main__":
+    from dotenv import load_dotenv
+
+    load_dotenv()
+    path = "data/Lecture_02_03.pdf"
+    output = Path(r"src\data\images").resolve()
+    model = init_chat_model(model="gpt-4o", model_provider="openai")
+    data = PDFMultiModalLLM(
+        prompt="What is in the image", pdf=path, model=model
+    ).invoke()
+    print(data)

pdf_segmentation-0.1.0/pdf_segmentation/src/pdf_seperator/__init__.py

@@ -0,0 +1 @@
+from .pdf_seperator import PDFSeperator

pdf_segmentation-0.1.0/pdf_segmentation/src/pdf_seperator/pdf_seperator.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+import pymupdf
+from type import PDFInput
+from typing import Sequence, Literal
+from pdf_image_converter import PDFImageConverter
+
+
+class PDFSeperator:
+    def __init__(
+        self,
+        pdf_path: PDFInput | None = None,
+        pdf_bytes: bytes | None = None,
+        image_bytes: Sequence[bytes] | None = None,
+        pdf_name: str | None = "input_pdf",
+    ):
+        self.pdf_name = pdf_name
+        if pdf_path is None and pdf_bytes is None and image_bytes is None:
+            raise ValueError(
+                "Either pdf_path or image_bytes or pdf_bytes must be provided"
+            )
+        if pdf_path is not None and pdf_bytes is not None and image_bytes is None:
+            raise ValueError("Provide only one of pdf_path or image_bytes")
+
+        if pdf_path is not None:
+            self.pdf = pymupdf.open(pdf_path).tobytes()
+        elif pdf_bytes:
+            self.pdf = pdf_bytes
+        elif image_bytes:
+            self.pdf = PDFImageConverter().images_to_pdf(image_bytes)
+
+        else:
+            raise ValueError("Unexpected Error Occured")
+
+    def extract_page_range(self, start: int, end: int) -> bytes:
+        src = pymupdf.open(stream=self.pdf, filetype="pdf")
+        dst = pymupdf.open()
+        dst.insert_pdf(src, from_page=start, to_page=end, rotate=0)
+        return dst.tobytes()
+
+    def _extract_and_save(
+        self,
+        start: int,
+        end: int,
+        output_dir: str | Path,
+        pdf_name: str,
+        method: Literal["pdf", "image"] = "pdf",
+    ) -> str:
+        output_dir = Path(output_dir).resolve()
+        if not output_dir.exists():
+            raise ValueError("Failed to extract pdf path {output_dir} does not exist")
+        data = self.extract_page_range(start, end)
+        output_path = output_dir / (f"{self.pdf_name}_extracted_{start}_{end}.pdf")
+        PDFImageConverter().save_to_images(data, output_dir, pdf_name)
+        return output_path.as_posix()
+
+
+if __name__ == "__main__":
+    path = r"data\Lecture_02_03.pdf"
+    PDFSeperator(path)._extract_and_save(
+        1, 3, output_dir="./data", pdf_name="pdf_extracted"
+    )

pdf_segmentation-0.1.0/pdf_segmentation/src/type/__init__.py

@@ -0,0 +1,2 @@
+from .types import *
+from .models import *

pdf_segmentation-0.1.0/pdf_segmentation/src/type/models.py

@@ -0,0 +1,12 @@
+from pydantic import BaseModel
+
+
+class BaseOutput(BaseModel):
+    data: str
+
+
+class PageRange(BaseModel):
+    start_page: int
+    end_page: int
+
+

pdf_segmentation-0.1.0/pdf_segmentation/src/type/types.py

@@ -0,0 +1,20 @@
+from pathlib import Path
+from typing import Literal
+from enum import Enum
+
+
+AnchorPos = Literal["top-left", "top-right", "bottom-right", "bottom-left"]
+ImageExt = Literal["png", "jpeg"]
+
+
+class Anchor(str, Enum):
+    TOP_LEFT = "top-left"
+    TOP_RIGHT = "top-right"
+    BOTTOM_RIGHT = "bottom-right"
+    BOTTOM_LEFT = "bottom-left"
+
+
+PDFInput = str | Path | bytes
+ImageBytes = bytes
+
+ImageInput = PDFInput | ImageBytes

pdf_segmentation-0.1.0/pdf_segmentation/src/utils/__init__.py

@@ -0,0 +1,3 @@
+from .image_utils import *
+from .langchain_utils import *
+from .serialization_utils import *

pdf_segmentation-0.1.0/pdf_segmentation/src/utils/image_utils.py

@@ -0,0 +1,37 @@
+from pathlib import Path
+import base64
+
+
+def save_base64_image(b64_data: str, output_path: str | Path) -> Path:
+    """
+    Decode a base64-encoded image and save it to disk.
+
+    Args:
+        b64_data: Base64-encoded image string (no data URI prefix).
+        output_path: Path where the image will be saved.
+
+    Returns:
+        Path to the saved image.
+    """
+    output_path = Path(output_path).resolve()
+
+    image_bytes = base64.b64decode(b64_data)
+    output_path.write_bytes(image_bytes)
+
+    return output_path
+
+
+def write_image_data(image_bytes: bytes, folder_path: str | Path, filename: str) -> str:
+    try:
+        path = Path(folder_path).resolve()
+        path.mkdir(exist_ok=True)
+        save_path = path / filename
+
+        if save_path.suffix != ".png":
+            raise ValueError(
+                "Suffix allowed is only PNG either missing or nnot allowed"
+            )
+        save_path.write_bytes(image_bytes)
+        return save_path.as_posix()
+    except Exception as e:
+        raise ValueError(f"Could not save image {str(e)}")

pdf_segmentation-0.1.0/pdf_segmentation/src/utils/langchain_utils.py

@@ -0,0 +1,19 @@
+from pathlib import Path
+from typing import Any
+from langgraph.graph.state import CompiledStateGraph
+from .image_utils import write_image_data
+
+
+def save_graph_visualization(
+    graph: CompiledStateGraph | Any,
+    folder_path: str | Path,
+    filename: str,
+):
+    try:
+        image_bytes = graph.get_graph().draw_mermaid_png()
+        save_path = write_image_data(image_bytes, folder_path, filename)
+        print(f"✅ Saved graph visualization at: {save_path}")
+    except ValueError:
+        raise
+    except Exception as error:
+        print(f"❌ Graph visualization failed: {error}")

pdf_segmentation-0.1.0/pdf_segmentation/src/utils/serialization_utils.py

@@ -0,0 +1,30 @@
+from pathlib import Path
+import base64
+from datetime import date, datetime, time
+from typing import Any
+from uuid import UUID
+from pydantic import BaseModel
+
+
+def to_serializable(obj: Any) -> Any:
+    """
+    Recursively convert Pydantic models (and nested dicts/lists thereof)
+    into plain Python data structures.
+    """
+    if isinstance(obj, BaseModel):
+        return obj.model_dump(mode="json")
+    if isinstance(obj, dict):
+        return {k: to_serializable(v) for k, v in obj.items()}
+    if isinstance(obj, list):
+        return [to_serializable(v) for v in obj]
+
+    # --- Special cases ---
+    if isinstance(obj, (datetime, date, time)):
+        return obj.isoformat()
+    if isinstance(obj, UUID):
+        return str(obj)
+    if isinstance(obj, Path):
+        return obj.as_posix()
+    if isinstance(obj, (bytes, bytearray, memoryview)):
+        return base64.b64encode(obj).decode("utf-8")
+    return obj

pdf_segmentation-0.1.0/pyproject.toml

@@ -0,0 +1,27 @@
+[project]
+name = "pdf_segmentation"
+version = "0.1.0"
+description = ""
+authors = [
+    {name = "Luciano Bermudez",email = "lucianobmecheng69@gmail.com"}
+]
+readme = "README.md"
+requires-python = ">=3.11,<4.0.0"
+dependencies = [
+    "langchain (>=1.2.8,<2.0.0)",
+    "pymupdf (>=1.26.7,<2.0.0)",
+    "langgraph (>=1.0.7,<2.0.0)",
+    "python-dotenv (>=1.2.1,<2.0.0)"
+]
+
+
+[build-system]
+requires = ["poetry-core>=2.0.0,<3.0.0"]
+build-backend = "poetry.core.masonry.api"
+
+[dependency-groups]
+dev = [
+    "langchain-openai (>=1.1.7,<2.0.0)",
+    "ipykernel (>=7.2.0,<8.0.0)"
+]
+