prevectorchunks-core 0.1.10__tar.gz → 0.1.28__tar.gz

prevectorchunks_core-0.1.28/LICENSE

@@ -0,0 +1,2 @@
+MIT License
+Copyright (c) 2025 Your Name

prevectorchunks_core-0.1.28/PKG-INFO

@@ -0,0 +1,272 @@
+Metadata-Version: 2.4
+Name: prevectorchunks-core
+Version: 0.1.28
+Summary: A Python module that allows conversion of a document into chunks to be inserted into Pinecone vector database
+Author-email: Zul Al-Kabir <zul.developer.2023@gmail.com>
+License: MIT License
+        Copyright (c) 2025 Your Name
+        
+Project-URL: Homepage, https://github.com/zuldeveloper2023/PreVectorChunks
+Project-URL: Source, https://github.com/zuldeveloper2023/PreVectorChunks
+Requires-Python: <3.12,>=3.7
+Description-Content-Type: text/markdown
+License-File: LICENCE
+License-File: LICENSE
+Requires-Dist: packaging~=24.1
+Requires-Dist: openai<3.0.0,>=2.6.0
+Requires-Dist: python-dotenv~=1.0.1
+Requires-Dist: PyJWT~=2.7.0
+Requires-Dist: fastapi~=0.112.2
+Requires-Dist: datasets~=4.1.0
+Requires-Dist: pinecone~=7.3.0
+Requires-Dist: pytesseract~=0.3.13
+Requires-Dist: python-docx~=1.2.0
+Requires-Dist: PyPDF2~=3.0.1
+Requires-Dist: pillow~=11.3.0
+Requires-Dist: torch~=2.6.0
+Requires-Dist: torchvision~=0.21.0
+Requires-Dist: torchaudio~=2.6.0
+Requires-Dist: sentence-transformers~=5.1.1
+Requires-Dist: py-gutenberg~=1.0.3
+Requires-Dist: langchain-text-splitters~=0.3.11
+Requires-Dist: langchain~=0.3
+Requires-Dist: langchain_openai~=0.3.35
+Requires-Dist: accelerate>=0.22.0
+Requires-Dist: pathlib~=1.0.1
+Requires-Dist: transformers~=4.57.0
+Requires-Dist: imageio-ffmpeg~=0.6.0
+Requires-Dist: opencv-python~=4.12.0.88
+Requires-Dist: requests~=2.32.5
+Requires-Dist: langchain-core~=0.3.78
+Requires-Dist: pdf2image~=1.17.0
+Requires-Dist: docx2pdf~=0.1.8
+Requires-Dist: numpy~=2.2.6
+Requires-Dist: scikit-learn~=1.7.2
+Requires-Dist: PyMuPDF~=1.22.5
+Requires-Dist: pypandoc~=1.13
+Requires-Dist: reportlab~=4.1.0
+Requires-Dist: weasyprint~=62.0
+Requires-Dist: lxml~=4.9.3
+Requires-Dist: cssselect2~=0.7.0
+Requires-Dist: cairocffi~=1.4.0
+Dynamic: license-file
+
+# 📚 PreVectorChunks
+
+> A lightweight utility for **document chunking** and **vector database upserts** — designed for developers building **RAG (Retrieval-Augmented Generation)** solutions.
+
+---
+
+## ✨ Who Needs This Module?
+Any developer working with:
+- **RAG pipelines**
+- **Vector Databases** (like Pinecone, Weaviate, etc.)
+- **AI applications** requiring **similar content retrieval**
+
+---
+
+## 🎯 What Does This Module Do?
+This module helps you:
+- **Chunk documents** into smaller fragments using:
+  - a pretrained Reinforcement Learning based model or
+  - a pretrained Reinforcement Learning based model with proposition indexing or
+  - standard word chunking
+  - recursive character based chunking
+  - character based chunking
+- **Insert (upsert) fragments** into a vector database  
+- **Fetch & update** existing chunks from a vector database  
+
+---
+
+## 📦 Installation
+```bash
+pip install prevectorchunks-core
+```
+
+How to import in a file:  
+```python
+from PreVectorChunks.services import chunk_documents_crud_vdb
+```
+
+**Use .env for API keys:IMPORTANT: PLEASE ENSURE TO PROVIDE YOUR OPENAI_API_KEY as MINIMUM in an .env file or as required**
+```
+PINECONE_API_KEY=YOUR_API_KEY
+OPENAI_API_KEY=YOUR_API_KEY
+```
+
+---
+
+## 📄 Functions
+
+### 1. `chunk_documents`
+```python
+chunk_documents(instructions, file_path="content_playground/content.json", splitter_config=SplitterConfig())
+```
+Splits the content of a document into smaller, manageable chunks. - Five types of document chunking
+- Chunking using Reinforcement Learning based pretrained model +(enable/disable LLM to structure the chunked text - default is enabled)
+- Chunking using Reinforcement Learning based pretrained model and proposition indexing +(enable/disable LLM to structure the chunked text - default is enabled)
+- Recursive Character based chunking +(enable/disable LLM to structure the chunked text - default is enabled)
+- Standard word based chunking+(enable/disable LLM to structure the chunked text - default is enabled)
+- Simple character based chunking +(enable/disable LLM to structure the chunked text - default is enabled)
+
+
+**Parameters**
+- `instructions` (*dict or str*): Additional rules or guidance for how the document should be split.  
+  - Example: `"split my content by biggest headings"`
+- `file_path` (*str*): Binary file or file path to the input file containing the content or content of the file. Default: `"content_playground/content.json"`.
+- `splitter_config (optional) ` (*SplitterConfig*): (if none provided standard split takes place) Object that defines chunking behavior, e.g., `chunk_size`, `chunk_overlap`, `separator`, `split_type`.
+- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type=SplitType.RECURSIVE.value)
+- (chunk_size refers to size in characters (i.e. 100 characters) when RECURSIVE is used)
+- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type=SplitType.CHARACTER.value)
+- - (chunk_size refers to size in characters (i.e. 100 characters) when CHARACTER is used)
+- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type=SplitType.STANDARD.value)
+- - (chunk_size refers to size in words (i.e. 100 characters) when STANDARD is used)
+- i.e. splitter_config = SplitterConfig(separators=["\n"],
+                                     split_type=SplitType.R_PRETRAINED.value, min_rl_chunk_size=5,
+                                     max_rl_chunk_size=50,enableLLMTouchUp=False)
+- - (min_rl_chunk_size and max_rl_chunk_size refers to size in sentences (i.e. 100 sentences) when R_PRETRAINED is used)
+- i.e. splitter_config = SplitterConfig(separators=["\n"],
+                                     split_type=SplitType.R_PRETRAINED_PROPOSITION.value, min_rl_chunk_size=5,
+                                     max_rl_chunk_size=50,enableLLMTouchUp=False)
+- - (min_rl_chunk_size and max_rl_chunk_size refers to size in sentences (i.e. 100 sentences) when R_PRETRAINED_PROPOSITION is used)
+
+- **Returns**
+- A list of chunked strings including a unique id, a meaningful title and chunked text
+
+**Use Cases**
+- Preparing text for LLM ingestion
+- Splitting text by structure (headings, paragraphs)
+- Vector database indexing
+
+---
+
+### 2. `chunk_and_upsert_to_vdb`
+```python
+chunk_and_upsert_to_vdb(index_n, instructions, file_path="content_playground/content.json", splitter_config=SplitterConfig())
+```
+Splits a document into chunks (via `chunk_documents`) and **inserts them into a Vector Database**.
+
+**Parameters**
+- `index_n` (*str*): The name of the VDB index where chunks should be stored.
+- `instructions` (*dict or str*): Rules for splitting content (same as `chunk_documents`).
+- `file_path` (*str*): Path to the document file or content of the file. Default: `"content_playground/content.json"`.
+- `splitter_config` (*SplitterConfig*): Object that defines chunking behavior.
+
+**Returns**
+- Confirmation of successful insert into the VDB.
+
+**Use Cases**
+- Automated document preprocessing and storage for vector search
+- Preparing embeddings for semantic search
+
+---
+
+### 3. `fetch_vdb_chunks_grouped_by_document_name`
+```python
+fetch_vdb_chunks_grouped_by_document_name(index_n)
+```
+Fetches existing chunks stored in the Vector Database, grouped by **document name**.
+
+**Parameters**
+- `index_n` (*str*): The name of the VDB index.
+
+**Returns**
+- A dictionary or list of chunks grouped by document name.
+
+**Use Cases**
+- Retrieving all chunks of a specific document
+- Verifying what content has been ingested into the VDB
+
+---
+
+### 4. `update_vdb_chunks_grouped_by_document_name`
+```python
+update_vdb_chunks_grouped_by_document_name(index_n, dataset)
+```
+Updates existing chunks in the Vector Database by document name.
+
+**Parameters**
+- `index_n` (*str*): The name of the VDB index.  
+- `dataset` (*dict or list*): The new data (chunks) to update existing entries.
+
+**Returns**
+- Confirmation of update status.
+
+**Use Cases**
+- Keeping VDB chunks up to date when documents change
+- Re-ingesting revised or corrected content
+
+---
+### 5. ``markdown_and_chunk_documents``
+```python
+from prevectorchunks_core.services.markdown_and_chunk_documents import MarkdownAndChunkDocuments
+
+markdown_processor = MarkdownAndChunkDocuments()
+mapped_chunks = markdown_processor.markdown_and_chunk_documents("example.pdf")
+```
+
+**Description**  
+This new function automatically:
+1. Converts a document (PDF, DOCX, etc.) into images using `DocuToImageConverter`.
+2. Extracts **Markdown and text** content from those images using `DocuToMarkdownExtractor` (powered by GPT).
+3. Converts the extracted markdown text into **RL-based chunks** using `ChunkMapper` and `chunk_documents`.
+4. Merges unmatched markdown segments into the final structured output.
+
+**Parameters**
+- `file_path` (*str*): Path to the document (PDF, DOCX, or image) you want to process.
+
+**Returns**
+- `mapped_chunks` (*list[dict]*): A list of markdown-based chunks with both markdown and chunked text content.
+
+**Example**
+```python
+if __name__ == "__main__":
+    markdown_processor = MarkdownAndChunkDocuments()
+    mapped_chunks = markdown_processor.markdown_and_chunk_documents("421307-nz-au-top-loading-washer-guide-shorter.pdf")
+    print(mapped_chunks)
+```
+
+**Use Cases**
+- End-to-end document-to-markdown-to-chunks pipeline
+- Automating preprocessing for RAG/LLM ingestion
+- Extracting structured markdown for semantic search or content indexing
+
+---
+
+## 🚀 Example Workflow
+```python
+from prevectorchunks_core.config import SplitterConfig
+
+splitter_config = SplitterConfig(chunk_size=150, chunk_overlap=0, separator=["\n"], split_type=SplitType.R_PRETRAINED_PROPOSITION.value)
+
+# Step 1: Chunk a document
+chunks = chunk_documents(
+    instructions="split my content by biggest headings",
+    file_path="content_playground/content.json",
+    splitter_config=splitter_config
+)
+
+splitter_config = SplitterConfig(chunk_size=300, chunk_overlap=0, separators=["\n"],
+                                     split_type=SplitType.R_PRETRAINED_PROPOSITION.value, min_rl_chunk_size=5,
+                                     max_rl_chunk_size=50,enableLLMTouchUp=False)
+
+chunks=chunk_documents_crud_vdb.chunk_documents("extract", file_name=None, file_path="content.txt",splitter_config=splitter_config)
+
+# Step 2: Insert chunks into VDB
+chunk_and_upsert_to_vdb("my_index", instructions="split by headings", splitter_config=splitter_config)
+
+# Step 3: Fetch stored chunks
+docs = fetch_vdb_chunks_grouped_by_document_name("my_index")
+
+# Step 4: Update chunks if needed
+update_vdb_chunks_grouped_by_document_name("my_index", dataset=docs)
+```
+
+---
+
+## 🛠 Use Cases
+- Preprocessing documents for LLM ingestion  
+- Semantic search and Q&A systems  
+- Vector database indexing and retrieval  
+- Maintaining versioned document chunks
+

prevectorchunks_core-0.1.10/PKG-INFO → prevectorchunks_core-0.1.28/README.md

@@ -1,32 +1,3 @@
-Metadata-Version: 2.4
-Name: prevectorchunks-core
-Version: 0.1.10
-Summary: A Python module that allows conversion of a document into chunks to be inserted into Pinecone vector database
-Author-email: Zul Al-Kabir <zul.developer.2023@gmail.com>
-Project-URL: Homepage, https://github.com/yourusername/mydep
-Description-Content-Type: text/markdown
-License-File: LICENCE
-Requires-Dist: packaging~=24.1
-Requires-Dist: requests~=2.32.3
-Requires-Dist: openai~=1.37.1
-Requires-Dist: python-dotenv~=1.0.1
-Requires-Dist: PyJWT~=2.7.0
-Requires-Dist: fastapi~=0.112.2
-Requires-Dist: datasets~=4.1.0
-Requires-Dist: pinecone~=7.3.0
-Requires-Dist: pytesseract~=0.3.13
-Requires-Dist: python-docx~=1.2.0
-Requires-Dist: PyPDF2~=3.0.1
-Requires-Dist: pillow~=11.3.0
-Requires-Dist: torch~=2.6.0
-Requires-Dist: torchvision~=0.21.0
-Requires-Dist: torchaudio~=2.6.0
-Requires-Dist: sentence-transformers~=5.1.1
-Requires-Dist: py-gutenberg~=1.0.3
-Requires-Dist: langchain-text-splitters~=0.3.11
-Requires-Dist: langchain~=0.3
-Dynamic: license-file
-
 # 📚 PreVectorChunks
 
 > A lightweight utility for **document chunking** and **vector database upserts** — designed for developers building **RAG (Retrieval-Augmented Generation)** solutions.
@@ -43,7 +14,12 @@ Any developer working with:
 
 ## 🎯 What Does This Module Do?
 This module helps you:
-- **Chunk documents** into smaller fragments  
+- **Chunk documents** into smaller fragments using:
+  - a pretrained Reinforcement Learning based model or
+  - a pretrained Reinforcement Learning based model with proposition indexing or
+  - standard word chunking
+  - recursive character based chunking
+  - character based chunking
 - **Insert (upsert) fragments** into a vector database  
 - **Fetch & update** existing chunks from a vector database  
 
@@ -59,7 +35,7 @@ How to import in a file:
 from PreVectorChunks.services import chunk_documents_crud_vdb
 ```
 
-**Use .env for API keys:**
+**Use .env for API keys:IMPORTANT: PLEASE ENSURE TO PROVIDE YOUR OPENAI_API_KEY as MINIMUM in an .env file or as required**
 ```
 PINECONE_API_KEY=YOUR_API_KEY
 OPENAI_API_KEY=YOUR_API_KEY
@@ -73,17 +49,35 @@ OPENAI_API_KEY=YOUR_API_KEY
 ```python
 chunk_documents(instructions, file_path="content_playground/content.json", splitter_config=SplitterConfig())
 ```
-Splits the content of a document into smaller, manageable chunks.
+Splits the content of a document into smaller, manageable chunks. - Five types of document chunking
+- Chunking using Reinforcement Learning based pretrained model +(enable/disable LLM to structure the chunked text - default is enabled)
+- Chunking using Reinforcement Learning based pretrained model and proposition indexing +(enable/disable LLM to structure the chunked text - default is enabled)
+- Recursive Character based chunking +(enable/disable LLM to structure the chunked text - default is enabled)
+- Standard word based chunking+(enable/disable LLM to structure the chunked text - default is enabled)
+- Simple character based chunking +(enable/disable LLM to structure the chunked text - default is enabled)
+
 
 **Parameters**
 - `instructions` (*dict or str*): Additional rules or guidance for how the document should be split.  
   - Example: `"split my content by biggest headings"`
-- `file_path` (*str*): Path to the input JSON/text file containing the content or content of the file. Default: `"content_playground/content.json"`.
+- `file_path` (*str*): Binary file or file path to the input file containing the content or content of the file. Default: `"content_playground/content.json"`.
 - `splitter_config (optional) ` (*SplitterConfig*): (if none provided standard split takes place) Object that defines chunking behavior, e.g., `chunk_size`, `chunk_overlap`, `separator`, `split_type`.
-- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type="RecursiveCharacterTextSplitter")
-- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type="CharacterTextSplitter")
-- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type="standard")
-**Returns**
+- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type=SplitType.RECURSIVE.value)
+- (chunk_size refers to size in characters (i.e. 100 characters) when RECURSIVE is used)
+- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type=SplitType.CHARACTER.value)
+- - (chunk_size refers to size in characters (i.e. 100 characters) when CHARACTER is used)
+- i.e. splitter_config = SplitterConfig(chunk_size= 300, chunk_overlap= 0,separators=["\n"],split_type=SplitType.STANDARD.value)
+- - (chunk_size refers to size in words (i.e. 100 characters) when STANDARD is used)
+- i.e. splitter_config = SplitterConfig(separators=["\n"],
+                                     split_type=SplitType.R_PRETRAINED.value, min_rl_chunk_size=5,
+                                     max_rl_chunk_size=50,enableLLMTouchUp=False)
+- - (min_rl_chunk_size and max_rl_chunk_size refers to size in sentences (i.e. 100 sentences) when R_PRETRAINED is used)
+- i.e. splitter_config = SplitterConfig(separators=["\n"],
+                                     split_type=SplitType.R_PRETRAINED_PROPOSITION.value, min_rl_chunk_size=5,
+                                     max_rl_chunk_size=50,enableLLMTouchUp=False)
+- - (min_rl_chunk_size and max_rl_chunk_size refers to size in sentences (i.e. 100 sentences) when R_PRETRAINED_PROPOSITION is used)
+
+- **Returns**
 - A list of chunked strings including a unique id, a meaningful title and chunked text
 
 **Use Cases**
@@ -149,13 +143,48 @@ Updates existing chunks in the Vector Database by document name.
 - Keeping VDB chunks up to date when documents change
 - Re-ingesting revised or corrected content
 
+---
+### 5. ``markdown_and_chunk_documents``
+```python
+from prevectorchunks_core.services.markdown_and_chunk_documents import MarkdownAndChunkDocuments
+
+markdown_processor = MarkdownAndChunkDocuments()
+mapped_chunks = markdown_processor.markdown_and_chunk_documents("example.pdf")
+```
+
+**Description**  
+This new function automatically:
+1. Converts a document (PDF, DOCX, etc.) into images using `DocuToImageConverter`.
+2. Extracts **Markdown and text** content from those images using `DocuToMarkdownExtractor` (powered by GPT).
+3. Converts the extracted markdown text into **RL-based chunks** using `ChunkMapper` and `chunk_documents`.
+4. Merges unmatched markdown segments into the final structured output.
+
+**Parameters**
+- `file_path` (*str*): Path to the document (PDF, DOCX, or image) you want to process.
+
+**Returns**
+- `mapped_chunks` (*list[dict]*): A list of markdown-based chunks with both markdown and chunked text content.
+
+**Example**
+```python
+if __name__ == "__main__":
+    markdown_processor = MarkdownAndChunkDocuments()
+    mapped_chunks = markdown_processor.markdown_and_chunk_documents("421307-nz-au-top-loading-washer-guide-shorter.pdf")
+    print(mapped_chunks)
+```
+
+**Use Cases**
+- End-to-end document-to-markdown-to-chunks pipeline
+- Automating preprocessing for RAG/LLM ingestion
+- Extracting structured markdown for semantic search or content indexing
+
 ---
 
 ## 🚀 Example Workflow
 ```python
 from prevectorchunks_core.config import SplitterConfig
 
-splitter_config = SplitterConfig(chunk_size=150, chunk_overlap=0, separator=["\n"], split_type="RecursiveCharacterTextSplitter")
+splitter_config = SplitterConfig(chunk_size=150, chunk_overlap=0, separator=["\n"], split_type=SplitType.R_PRETRAINED_PROPOSITION.value)
 
 # Step 1: Chunk a document
 chunks = chunk_documents(
@@ -164,6 +193,12 @@ chunks = chunk_documents(
     splitter_config=splitter_config
 )
 
+splitter_config = SplitterConfig(chunk_size=300, chunk_overlap=0, separators=["\n"],
+                                     split_type=SplitType.R_PRETRAINED_PROPOSITION.value, min_rl_chunk_size=5,
+                                     max_rl_chunk_size=50,enableLLMTouchUp=False)
+
+chunks=chunk_documents_crud_vdb.chunk_documents("extract", file_name=None, file_path="content.txt",splitter_config=splitter_config)
+
 # Step 2: Insert chunks into VDB
 chunk_and_upsert_to_vdb("my_index", instructions="split by headings", splitter_config=splitter_config)
 

prevectorchunks_core-0.1.28/prevectorchunks_core/config/splitter_config.py

@@ -0,0 +1,22 @@
+# prevectorchunks_core/config.py
+from dataclasses import dataclass, field
+from enum import Enum
+
+
+class LLM_Structured_Output_Type(Enum):
+    STANDARD = "STANDARD"
+    STRUCTURED_WITH_VECTOR_DB_ID_GENERATED = "STRUCTURED_WITH_VECTOR_DB_ID_GENERATED"
+
+
+@dataclass()
+class SplitterConfig:
+    chunk_size: int = 300
+    chunk_overlap: int = 0
+    separators: list[str] = field(default_factory=lambda: ["\n"])
+    split_type: str = "recursive_splitter"
+    enableLLMTouchUp: bool = True
+    llm_structured_output_type: LLM_Structured_Output_Type = LLM_Structured_Output_Type.STRUCTURED_WITH_VECTOR_DB_ID_GENERATED
+    min_rl_chunk_size: int = 5
+    max_rl_chunk_size: int = 50
+
+

prevectorchunks_core-0.1.28/prevectorchunks_core/os-llm/llava.py

@@ -0,0 +1,15 @@
+from transformers import pipeline
+
+pipe = pipeline("image-text-to-text", model="llava-hf/llava-1.5-13b-hf")
+messages = [
+    {
+      "role": "user",
+      "content": [
+          {"type": "image", "url": "https://huggingface.co/datasets/huggingface/documentation-images/resolve/main/transformers/tasks/ai2d-demo.jpg"},
+          {"type": "text", "text": "What does the label 15 represent? (1) lava (2) core (3) tunnel (4) ash cloud"},
+        ],
+    },
+]
+
+out = pipe(text=messages, max_new_tokens=20)
+print(out)

prevectorchunks_core-0.1.28/prevectorchunks_core/rlchunker/pretrained/model_info.txt

@@ -0,0 +1,2 @@
+RL-based text chunking pretrained model
+Embedding model: all-MiniLM-L6-v2

prevectorchunks_core-0.1.28/prevectorchunks_core/services/DocuToImageConverter.py

@@ -0,0 +1,148 @@
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+from pathlib import Path
+
+import pypandoc
+from PIL import Image
+import io
+from docx2pdf import convert as docx_to_pdf
+import fitz
+from docx2pdf import convert as docx2pdf_convert
+try:
+    pypandoc.get_pandoc_path()
+except OSError:
+    print("Pandoc not found — downloading it temporarily...")
+    pypandoc.download_pandoc()
+
+class DocuToImageConverter:
+    """Converts a document (PDF, DOCX, DOC) into a list of PIL images."""
+
+    def __init__(self):
+        pass
+
+    def _convert_doc_to_pdf(self, input_path: str) -> str:
+        import os, tempfile, shutil, subprocess
+        from pathlib import Path
+
+        if not os.path.exists(input_path):
+            raise FileNotFoundError(input_path)
+
+        output_dir = tempfile.mkdtemp()
+        output_pdf = os.path.join(output_dir, Path(input_path).stem + ".pdf")
+
+        # 1️⃣ Try Microsoft Word COM automation (Windows only)
+        try:
+            import win32com.client
+            word = win32com.client.Dispatch("Word.Application")
+            word.Visible = False
+            doc = word.Documents.Open(str(Path(input_path).resolve()))
+            doc.SaveAs(str(Path(output_pdf).resolve()), FileFormat=17)  # 17 = wdFormatPDF
+            doc.Close()
+            word.Quit()
+            print("✅ Word COM conversion successful:", output_pdf)
+            return output_pdf
+        except Exception as e:
+            print("⚠️ Word COM conversion failed:", e)
+
+        # 2️⃣ Fallback: LibreOffice (cross-platform, preserves layout)
+        try:
+            # Requires LibreOffice installed and in PATH
+            subprocess.run(
+                ["soffice", "--headless", "--convert-to", "pdf", "--outdir", output_dir, input_path],
+                check=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
+            print("✅ LibreOffice conversion successful:", output_pdf)
+            return output_pdf
+        except Exception as e:
+            print("⚠️ LibreOffice conversion failed:", e)
+
+        # 3️⃣ Fallback: Pandoc (simpler, loses layout)
+        try:
+            import pypandoc
+            def which(cmd):
+                return shutil.which(cmd) is not None
+
+            pdf_engine = "pdflatex" if which("pdflatex") else "wkhtmltopdf"
+            pypandoc.convert_file(
+                input_path, "pdf", outputfile=output_pdf,
+                extra_args=["--standalone", f"--pdf-engine={pdf_engine}"]
+            )
+            print("✅ Pandoc conversion successful:", output_pdf)
+            return output_pdf
+        except Exception as e:
+            print("⚠️ Pandoc conversion failed:", e)
+
+        # 4️⃣ Last resort: ReportLab basic text (no formatting)
+        from reportlab.pdfgen import canvas
+        from reportlab.lib.pagesizes import A4
+        from docx import Document
+
+        doc = Document(input_path)
+        c = canvas.Canvas(output_pdf, pagesize=A4)
+        width, height = A4
+        y = height - 50
+        for p in doc.paragraphs:
+            c.drawString(50, y, p.text[:1000])
+            y -= 15
+            if y < 50:
+                c.showPage()
+                y = height - 50
+        c.save()
+        print("⚠️ Fallback to plain ReportLab text output:", output_pdf)
+        return output_pdf
+
+    def _convert_pdf_to_images(self, pdf_path: str, dpi: int = 200):
+        """
+        Converts each page of a PDF into images using PyMuPDF directly.
+        """
+        images = []
+
+        try:
+            pdf_document = fitz.open(pdf_path)  # Use `PyMuPDF` instead of fitz alias
+            for page_num in range(len(pdf_document)):
+                page = pdf_document[page_num]
+                # Render page to a pixmap with the specified DPI
+                pixmap = page.get_pixmap(dpi=dpi)
+                # Convert pixmap to an Image object using PIL
+                image = Image.frombytes("RGB", [pixmap.width, pixmap.height], pixmap.samples)
+                images.append(image)
+            pdf_document.close()
+        except Exception as e:
+            raise RuntimeError(f"Failed to convert PDF to images: {e}")
+
+        return images
+
+    def convert_to_images(self, file_path: str, dpi: int = 200, output_format: str = "PNG"):
+        """
+        Converts each page of a document into a list of PIL images.
+        Supports .pdf, .doc, .docx, and image files (.jpg, .png, etc.)
+        Ensures all outputs are in a consistent image format.
+        """
+        ext = os.path.splitext(file_path)[1].lower()
+
+        # Convert Word → PDF first
+        if ext in [".doc", ".docx"]:
+            pdf_path = self._convert_doc_to_pdf(file_path)
+            images = self._convert_pdf_to_images(pdf_path, dpi=dpi)
+
+        # Convert PDF → list of images
+        elif ext == ".pdf":
+            images = self._convert_pdf_to_images(file_path, dpi=dpi)
+
+        # Handle already an image file
+        elif ext in [".jpg", ".jpeg", ".png", ".bmp", ".tiff"]:
+            image = Image.open(file_path).convert("RGB")
+            # Convert to consistent format (e.g., PNG or JPEG in memory)
+            buffer = io.BytesIO()
+            image.save(buffer, format=output_format)
+            buffer.seek(0)
+            converted_image = Image.open(buffer)
+            images = [converted_image]
+
+        else:
+            raise ValueError("Unsupported file type. Use .pdf, .doc, .docx, or image files")
+
+        return images