first commit

.python-version

@@ -0,0 +1 @@
+3.13

Dockerfile

@@ -0,0 +1,22 @@
+FROM python:3.10-slim
+
+# Install system dependencies
+RUN apt-get update && apt-get install -y \
+    tesseract-ocr \
+    poppler-utils \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set work directory
+WORKDIR /app
+
+# Copy requirements
+COPY requirements.txt .
+
+# Install python dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy app code
+COPY . .
+
+# Run Streamlit app
+CMD ["streamlit", "run", "app.py", "--server.port", "7860", "--server.address", "0.0.0.0"]

README.md

@@ -1,11 +1,18 @@
 ---
-title: Pdf Toolbox
-emoji: 📉
-colorFrom: green
-colorTo: yellow
-sdk: docker
+title: PDF AI Toolkit (Streamlit + FAISS RAG)
+emoji: 🧰
+colorFrom: blue
+colorTo: indigo
+sdk: streamlit
+app_file: main.py
+python_version: "3.10"
 pinned: false
-license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# PDF AI Toolkit
+
+A Streamlit app for PDF processing (split/merge/extract/rotate/watermark/metadata), OCR (Tesseract), table & image extraction, and analysis (FAISS RAG + Together.ai Llama).  
+See the sidebar to pick **PDF Processing**, **Advanced processing**, **Analysis**, or **Export** tools.
+
+## Secrets
+Add `TOGETHER_API_KEY` in your Space → **Settings → Secrets**.

main.py

@@ -0,0 +1,255 @@
+import os
+import tempfile
+import zipfile
+import io
+import streamlit as st
+from utils.pdf_processing import (
+    split_pdf_pages, merge_pdfs, extract_page_range, remove_first_last_pages,
+    extract_text_from_pdf, keyword_highlight_pdf, extract_images, extract_tables,
+    ocr_pdf, reorder_pages, rotate_pages, add_watermark, extract_metadata
+)
+from utils.pdf_analysis import rag_qa, summarize_text
+from utils.pdf_export import export_to_word, export_to_text, export_text_to_markdown
+
+
+st.set_page_config(page_title="PDF Toolkit", layout="wide")
+st.title("🛠 PDF Toolkit")
+
+with st.sidebar:
+    st.header("Tools")
+    # Define tool categories
+    tool_categories = {
+        "PDF Processing": [
+            "Split PDF Pages",
+            "Merge PDFs",
+            "Extract Page Range",
+            "Remove First/Last Pages",
+        ],
+        "Advanced Processing": [
+            "Keyword Search & Highlight",
+            "Extract Images",
+            "Extract Tables",
+            "OCR Scanned PDF",
+            "Reorder Pages",
+            "Rotate Pages",
+            "Add Watermark",
+            "Extract Metadata",
+        ],
+        "Analysis": [
+            "Summarize PDF",
+            "Ask Questions on PDF (RAG)",
+        ],
+        "Export": [
+            "Export to Word (.docx)",
+            "Export to Text (.txt)",
+            "Export to Markdown (.md)",
+        ],
+    }
+
+    # Step 1: User selects category
+    selected_category = st.selectbox(
+        "Choose a Category",
+        list(tool_categories.keys())
+    )
+
+    # Step 2: Show tools under that category
+    tool = st.selectbox(
+        "Choose a Tool",
+        tool_categories[selected_category]
+    )
+    # st.caption("Note: For OCR, ensure Tesseract is installed on system path.")
+
+
+# ------------- Helpers for downloads -------------
+def download_bytes(label: str, data: bytes, file_name: str, mime: str):
+    st.download_button(label, data, file_name=file_name, mime=mime)
+
+
+def zip_folder_to_bytes(folder_path: str) -> bytes:
+    mem = io.BytesIO()
+    with zipfile.ZipFile(mem, "w", zipfile.ZIP_DEFLATED) as zf:
+        for root, _, files in os.walk(folder_path):
+            for f in files:
+                full = os.path.join(root, f)
+                arc = os.path.relpath(full, start=folder_path)
+                zf.write(full, arcname=arc)
+    mem.seek(0)
+    return mem.read()
+
+
+OUTPUT_DIR = "outputs"
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+def out_file(name: str) -> str:
+    return os.path.join(OUTPUT_DIR, name)
+
+# ------------- UI Logic -------------
+
+# Most tools need a PDF file, except "Merge PDFs"
+if tool == "Merge PDFs":
+    uploaded_files = st.file_uploader("Upload PDFs to merge", type=["pdf"], accept_multiple_files=True)
+    if uploaded_files:
+        if st.button("Merge"):
+            merged = merge_pdfs(uploaded_files)  # returns BytesIO
+            download_bytes("📥 Download Merged PDF", merged.getvalue(), "merged.pdf", "application/pdf")
+else:
+    uploaded = st.file_uploader("Upload PDF", type=["pdf"])
+    if uploaded:
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".pdf") as tmp:
+            tmp.write(uploaded.read())
+            pdf_path = tmp.name
+
+        if tool == "Split PDF Pages":
+            # Read total pages for UI
+            from PyPDF2 import PdfReader as _Reader
+            total_pages = len(_Reader(pdf_path).pages)
+            option = st.radio("Select Option", ["All Pages", "Page Range", "Single Page"], horizontal=True)
+
+            if option == "All Pages":
+                start_page, end_page = 1, total_pages
+            elif option == "Page Range":
+                start_page = st.number_input("Start Page", 1, total_pages, 1)
+                end_page = st.number_input("End Page", start_page, total_pages, total_pages)
+            else:
+                start_page = st.number_input("Page Number", 1, total_pages, 1)
+                end_page = start_page
+
+            if st.button("Split & Download ZIP"):
+                zip_bytesio = split_pdf_pages(pdf_path, int(start_page), int(end_page))
+                download_bytes("📥 Download ZIP", zip_bytesio.getvalue(), "split_pages.zip", "application/zip")
+
+        elif tool == "Extract Page Range":
+            from PyPDF2 import PdfReader as _Reader
+            total_pages = len(_Reader(pdf_path).pages)
+            start_page = st.number_input("Start Page", 1, total_pages, 1)
+            end_page = st.number_input("End Page", start_page, total_pages, total_pages)
+            if st.button("Extract Range"):
+                out = extract_page_range(pdf_path, int(start_page), int(end_page))
+                download_bytes("📥 Download Extracted PDF", out.getvalue(), "extracted_range.pdf", "application/pdf")
+
+        elif tool == "Remove First/Last Pages":
+            remove_first = st.checkbox("Remove First Page", value=True)
+            remove_last = st.checkbox("Remove Last Page", value=False)
+            if st.button("Remove & Download"):
+                out = remove_first_last_pages(pdf_path, remove_first, remove_last)
+                download_bytes("📥 Download Modified PDF", out.getvalue(), "modified.pdf", "application/pdf")
+
+        elif tool == "Keyword Search & Highlight":
+            keyword = st.text_input("Keyword to highlight", "")
+            if st.button("Search & Highlight") and keyword.strip():
+                out_path = keyword_highlight_pdf(pdf_path, keyword.strip(), out_file("highlighted.pdf"))
+                with open(out_path, "rb") as f:
+                    download_bytes("📥 Download Highlighted PDF", f.read(), "highlighted.pdf", "application/pdf")
+
+        elif tool == "Extract Images":
+            folder = extract_images(pdf_path, output_folder="images_out")
+            # st.success(f"Extracted images → {folder}")
+            if isinstance(folder, list):
+                folder = folder[0]
+
+            if os.path.isdir(folder) and len(os.listdir(folder)) > 0:
+                zbytes = zip_folder_to_bytes(folder)
+                download_bytes("📥 Download Images (ZIP)", zbytes, "images.zip", "application/zip")
+                image_files = [os.path.join(folder, f) for f in sorted(os.listdir(folder))]
+                # st.write("### Extracted Images Preview")
+                cols = st.columns(3)  # grid with 3 columns
+                for i, img in enumerate(image_files):
+                    with cols[i % 3]:
+                        st.image(img, caption=os.path.basename(img), use_container_width=True)
+
+        elif tool == "Extract Tables":
+            tables = extract_tables(pdf_path)
+            if not tables:
+                st.info("No tables detected.")
+            else:
+                try:
+                    import pandas as pd
+                except ImportError:
+                    st.warning("Install pandas to view tables nicely.")
+                    st.write(tables)
+                else:
+                    for i, t in enumerate(tables):
+                        if hasattr(t, "to_csv"):  # Camelot DataFrame
+                            df = t
+                        else:  # pdfplumber list-of-rows
+                            df = pd.DataFrame(t)
+                        st.subheader(f"Table {i+1}")
+                        st.dataframe(df)
+
+        elif tool == "OCR Scanned PDF":
+            # st.info("Requires Tesseract installed on your system.")
+            lang = st.selectbox(
+                "Select OCR language",
+                ["eng", "hin", "fra", "deu", "jpn", "kor"],  # Add more as needed
+                index=0
+            )
+            if st.button("Run OCR"):
+                text = ocr_pdf(pdf_path, lang)
+                st.text_area("OCR Output", text, height=300)
+
+        elif tool == "Reorder Pages":
+            st.caption("Enter comma-separated 0-indexed page order. Example for 3 pages: 2,0,1")
+            order_str = st.text_input("New order", "")
+            if st.button("Reorder") and order_str.strip():
+                new_order = [int(x.strip()) for x in order_str.split(",") if x.strip().isdigit()]
+                out_path = reorder_pages(pdf_path, new_order, out_file("reordered.pdf"))
+                with open(out_path, "rb") as f:
+                    download_bytes("📥 Download Reordered PDF", f.read(), "reordered.pdf", "application/pdf")
+
+        elif tool == "Rotate Pages":
+            st.caption("Enter 0-indexed pages, comma-separated. Angle typically 90/180/270.")
+            pages_str = st.text_input("Pages to rotate", "")
+            angle = st.number_input("Angle", min_value=0, max_value=360, value=90, step=90)
+            if st.button("Rotate") and pages_str.strip():
+                pages = [int(x.strip()) for x in pages_str.split(",") if x.strip().isdigit()]
+                out_path = rotate_pages(pdf_path, pages, int(angle), out_file("rotated.pdf"))
+                with open(out_path, "rb") as f:
+                    download_bytes("📥 Download Rotated PDF", f.read(), "rotated.pdf", "application/pdf")
+
+        elif tool == "Add Watermark":
+            wm = st.text_input("Watermark text", "CONFIDENTIAL")
+            if st.button("Apply Watermark"):
+                out_path = add_watermark(pdf_path, wm, out_file("watermarked.pdf"))
+                with open(out_path, "rb") as f:
+                    download_bytes("📥 Download Watermarked PDF", f.read(), "watermarked.pdf", "application/pdf")
+
+        elif tool == "Extract Metadata":
+            meta = extract_metadata(pdf_path)
+            st.json(meta)
+
+        elif tool == "Summarize PDF":
+            text = extract_text_from_pdf(pdf_path)
+            # st.info("Using Together.ai LLaMA for summarization. Set TOGETHER_API_KEY in your environment.")
+            if st.button("Summarize"):
+                with st.spinner("Summarizing... Please wait ⏳"):
+                    summary = summarize_text(text)
+                st.write(summary)
+
+        elif tool == "Ask Questions on PDF (RAG)":
+            # st.info("Uses FAISS + MiniLM embeddings + Together.ai LLaMA. Set TOGETHER_API_KEY in your environment.")
+            question = st.text_input("Your question")
+            if st.button("Ask") and question.strip():
+                text = extract_text_from_pdf(pdf_path)
+                with st.spinner("Analyzing... Please wait ⏳"):
+                    answer, sources = rag_qa(text, question)
+                st.subheader("Answer")
+                st.write(answer)
+                if sources:
+                    st.subheader("Top source chunks")
+                    for i, s in enumerate(sources, start=1):
+                        st.markdown(f"**Source {i}:**\n\n{getattr(s, 'page_content', '')[:800]}")
+
+        elif tool == "Export to Word (.docx)":
+            out = export_to_word(pdf_path, out_file("export.docx"))
+            with open(out, "rb") as f:
+                download_bytes("📥 Download DOCX", f.read(), "export.docx", "application/vnd.openxmlformats-officedocument.wordprocessingml.document")
+
+        elif tool == "Export to Text (.txt)":
+            out = export_to_text(pdf_path, out_file("export.txt"))
+            with open(out, "rb") as f:
+                download_bytes("📥 Download TXT", f.read(), "export.txt", "text/plain")
+
+        elif tool == "Export to Markdown (.md)":
+            text = extract_text_from_pdf(pdf_path)
+            out = export_text_to_markdown(text, out_file("export.md"))
+            with open(out, "rb") as f:
+                download_bytes("📥 Download MD", f.read(), "export.md", "text/markdown")

requirements.txt

@@ -0,0 +1,23 @@
+streamlit
+pymupdf==1.24.9
+PyPDF2
+pdfplumber
+pytesseract
+pdf2image
+Pillow
+faiss-cpu
+sentence-transformers
+langchain>=0.2.0
+langchain-community>=0.2.0
+huggingface_hub
+together
+python-docx
+pypandoc
+numpy
+pandas
+tesseract-ocr
+tesseract-ocr-eng
+poppler-utils    
+ghostscript       
+libgl1          
+pandoc

utils/pdf_analysis.py

@@ -0,0 +1,54 @@
+import os
+from langchain.vectorstores import FAISS
+from langchain.embeddings import HuggingFaceEmbeddings
+from langchain.text_splitter import RecursiveCharacterTextSplitter
+from langchain.chains import RetrievalQA
+from langchain.chat_models import ChatOpenAI
+
+from dotenv import load_dotenv
+load_dotenv()
+
+# Build FAISS retriever from raw text
+def build_retriever_from_text(text: str, chunk_size: int = 800, overlap: int = 100, k: int = 3):
+    splitter = RecursiveCharacterTextSplitter(chunk_size=chunk_size, chunk_overlap=overlap)
+    chunks = splitter.split_text(text)
+    embeddings = HuggingFaceEmbeddings(model_name="sentence-transformers/all-MiniLM-L6-v2")
+    vs = FAISS.from_texts(chunks, embeddings)
+    return vs.as_retriever(search_kwargs={"k": k})
+
+
+# Together.ai LLM (LLaMA) factory
+def together_llm(model: str = "meta-llama/Llama-Vision-Free", temperature: float = 0.2, max_tokens: int = 512):
+    return ChatOpenAI(
+        model=model,
+        temperature=temperature,
+        max_tokens=max_tokens,
+        openai_api_key=os.getenv("TOGETHER_API_KEY"),
+        openai_api_base="https://api.together.xyz/v1"
+    )
+
+
+# Q&A over PDF (RAG)
+def rag_qa(text: str, question: str, model: str = "meta-llama/Llama-Vision-Free"):
+    retriever = build_retriever_from_text(text)
+    llm = together_llm(model=model)
+    qa = RetrievalQA.from_chain_type(
+        llm=llm,
+        retriever=retriever,
+        return_source_documents=True,
+        chain_type="stuff"
+    )
+    result = qa({"query": question})
+    return result["result"], result.get("source_documents", [])
+
+
+# Summarize PDF text
+def summarize_text(text: str, model: str = "meta-llama/Llama-Vision-Free"):
+    prompt = (
+        "You are a concise technical summarizer. Summarize the following document in 6-10 bullet points, "
+        "preserving key facts, numbers, and definitions. Text:\n\n"
+        f"{text}"
+    )
+    llm = together_llm(model=model, temperature=0.2, max_tokens=400)
+    output = llm.invoke(prompt)
+    return output.content.strip()

utils/pdf_export.py

@@ -0,0 +1,28 @@
+import fitz
+from pdf2docx import Converter
+import pypandoc
+
+
+def export_to_word(pdf_path: str, output_path: str = "output.docx") -> str:
+    """Convert PDF to DOCX (layout-aware)."""
+    cv = Converter(pdf_path)
+    cv.convert(output_path, start=0, end=None)
+    cv.close()
+    return output_path
+
+
+def export_to_text(pdf_path: str, output_path: str = "output.txt") -> str:
+    """Export selectable text to TXT."""
+    text = ""
+    with fitz.open(pdf_path) as doc:
+        for page in doc:
+            text += page.get_text()
+    with open(output_path, "w", encoding="utf-8") as f:
+        f.write(text)
+    return output_path
+
+
+def export_text_to_markdown(text: str, output_path: str = "output.md") -> str:
+    """Export text (already extracted) to Markdown."""
+    pypandoc.convert_text(text, "md", format="md", outputfile=output_path, extra_args=["--standalone"])
+    return output_path

utils/pdf_processing.py

@@ -0,0 +1,195 @@
+import os
+import io
+import zipfile
+import fitz  # PyMuPDF
+from PIL import Image
+import pytesseract
+import pdfplumber
+import camelot
+from PyPDF2 import PdfReader, PdfWriter
+
+
+# -------------------------
+# BASIC PDF TOOLS (your originals)
+# -------------------------
+
+def split_pdf_pages(pdf_path: str, start_page: int, end_page: int) -> io.BytesIO:
+    """
+    Split selected pages into separate PDFs and return a ZIP (in-memory).
+    start_page/end_page are 1-indexed (inclusive).
+    """
+    reader = PdfReader(pdf_path)
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w") as zipf:
+        for i in range(start_page, end_page + 1):
+            writer = PdfWriter()
+            writer.add_page(reader.pages[i - 1])
+            pdf_bytes = io.BytesIO()
+            writer.write(pdf_bytes)
+            pdf_bytes.seek(0)
+            zipf.writestr(f"page_{i}.pdf", pdf_bytes.read())
+    zip_buffer.seek(0)
+    return zip_buffer
+
+
+def merge_pdfs(files_or_paths) -> io.BytesIO:
+    """
+    Merge multiple PDFs. Accepts a list of file-like objects or file paths.
+    Returns merged PDF as BytesIO.
+    """
+    writer = PdfWriter()
+    for f in files_or_paths:
+        reader = PdfReader(f) if hasattr(f, "read") else PdfReader(str(f))
+        for page in reader.pages:
+            writer.add_page(page)
+    out = io.BytesIO()
+    writer.write(out)
+    out.seek(0)
+    return out
+
+
+def extract_page_range(pdf_path: str, start_page: int, end_page: int) -> io.BytesIO:
+    """Extract a page range (1-indexed, inclusive) into a single PDF (in-memory)."""
+    reader = PdfReader(pdf_path)
+    writer = PdfWriter()
+    for i in range(start_page, end_page + 1):
+        writer.add_page(reader.pages[i - 1])
+    out = io.BytesIO()
+    writer.write(out)
+    out.seek(0)
+    return out
+
+
+def remove_first_last_pages(pdf_path: str, remove_first: bool, remove_last: bool) -> io.BytesIO:
+    """Remove first and/or last page and return modified PDF (in-memory)."""
+    reader = PdfReader(pdf_path)
+    writer = PdfWriter()
+    total = len(reader.pages)
+    for i in range(total):
+        if (remove_first and i == 0) or (remove_last and i == total - 1):
+            continue
+        writer.add_page(reader.pages[i])
+    out = io.BytesIO()
+    writer.write(out)
+    out.seek(0)
+    return out
+
+
+# -------------------------
+# ADVANCED UTILITIES
+# -------------------------
+
+def extract_text_from_pdf(pdf_path: str) -> str:
+    """Extract selectable text (not OCR) via PyMuPDF."""
+    text = ""
+    with fitz.open(pdf_path) as doc:
+        for page in doc:
+            text += page.get_text()
+    return text
+
+
+def keyword_highlight_pdf(pdf_path: str, keyword: str, output_path: str = "highlighted.pdf") -> str:
+    """Search keyword and highlight occurrences in the PDF (case-insensitive)."""
+    doc = fitz.open(pdf_path)
+    for page in doc:
+        matches = page.search_for(keyword, quads=False)
+        for rect in matches:
+            page.add_highlight_annot(rect)
+    doc.save(output_path, garbage=4, deflate=True)
+    return output_path
+
+
+def extract_images(pdf_path: str, output_folder: str = "extracted_images") -> list[str]:
+    """Extract embedded images to a folder; returns list of saved image paths."""
+    os.makedirs(output_folder, exist_ok=True)
+    doc = fitz.open(pdf_path)
+
+    for page_num in range(len(doc)):
+        page = doc[page_num]
+        images = page.get_images(full=True)
+        for img_index, img in enumerate(images):
+            xref = img[0]
+            base_image = doc.extract_image(xref)
+            image_bytes = base_image["image"]
+            image_ext = base_image["ext"]
+            image_filename = os.path.join(
+                output_folder,
+                f"page_{page_num+1}_img_{img_index+1}.{image_ext}"
+            )
+            with open(image_filename, "wb") as f:
+                f.write(image_bytes)
+
+    return output_folder
+
+
+def extract_tables(pdf_path: str):
+    """
+    Try Camelot first; fall back to pdfplumber.
+    Returns list of DataFrames (Camelot) or list-of-rows tables (pdfplumber).
+    """
+    try:
+        tables = camelot.read_pdf(pdf_path, pages="all")
+        if tables.n > 0:
+            return [t.df for t in tables]
+    except Exception:
+        pass
+
+    results = []
+    with pdfplumber.open(pdf_path) as pdf:
+        for page in pdf.pages:
+            page_tables = page.extract_tables()
+            results.extend(page_tables or [])
+    return results
+
+
+def ocr_pdf(pdf_path: str, lang: str = "eng") -> str:
+    """OCR image-only pages via Tesseract and PyMuPDF rasterization."""
+    text = ""
+    with fitz.open(pdf_path) as doc:
+        for page in doc:
+            pix = page.get_pixmap()
+            img = Image.open(io.BytesIO(pix.tobytes("png")))
+            custom_config = r'--oem 3 --psm 6'
+            text += pytesseract.image_to_string(img, lang=lang, config=custom_config) + "\n"
+    return text
+
+
+def reorder_pages(pdf_path: str, new_order: list[int], output_path: str = "reordered.pdf") -> str:
+    """Reorder pages by 0-indexed positions. Saves to output_path."""
+    src = fitz.open(pdf_path)
+    dst = fitz.open()
+    for i in new_order:
+        dst.insert_pdf(src, from_page=i, to_page=i)
+    dst.save(output_path)
+    return output_path
+
+
+def rotate_pages(pdf_path: str, pages_to_rotate: list[int], angle: int, output_path: str = "rotated.pdf") -> str:
+    """Rotate selected 0-indexed pages by angle (e.g., 90/180/270)."""
+    doc = fitz.open(pdf_path)
+    for p in pages_to_rotate:
+        doc[p].set_rotation(angle)
+    doc.save(output_path)
+    return output_path
+
+
+def add_watermark(pdf_path: str, watermark_text: str, output_path: str = "watermarked.pdf") -> str:
+    """Add semi-transparent diagonal text watermark to all pages."""
+    doc = fitz.open(pdf_path)
+    for page in doc:
+        rect = page.rect
+        page.insert_text(
+            (rect.width * 0.25, rect.height * 0.5),
+            watermark_text,
+            fontsize=30,
+            rotate=0,
+            color=(0.59, 0.59, 0.59)
+        )
+    doc.save(output_path)
+    return output_path
+
+
+def extract_metadata(pdf_path: str) -> dict:
+    """Return PDF metadata dictionary."""
+    with fitz.open(pdf_path) as doc:
+        return doc.metadata or {}