Initial deployment setup for Summarization_Deploy

hf_space_deployment/.dockerignore

@@ -0,0 +1,10 @@
+__pycache__/
+*.pyc
+.env
+output/
+tmp/
+*.zip
+.ipynb_checkpoints/
+.git/
+.gitignore
+README.md

hf_space_deployment/.gitattributes

@@ -0,0 +1 @@
+* text=auto

hf_space_deployment/.gitignore

@@ -0,0 +1,7 @@
+__pycache__/
+*.pyc
+.env
+output/
+tmp/
+*.zip
+.ipynb_checkpoints/

hf_space_deployment/Dockerfile

@@ -0,0 +1,35 @@
+FROM python:3.9-slim
+ENV HF_HOME=/tmp/huggingface
+
+# Install system dependencies
+# HF spaces runs on Debian-based images
+RUN apt-get update && apt-get install -y \
+    poppler-utils \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    tesseract-ocr-ara \
+    && rm -rf /var/lib/apt/lists/*
+
+# Set up a new user named "user" with user ID 1000
+RUN useradd -m -u 1000 user
+USER user
+ENV PATH="/home/user/.local/bin:$PATH"
+
+# Set working directory
+WORKDIR /app
+
+# Copy requirements and install
+COPY --chown=user requirements.txt .
+RUN pip install --no-cache-dir --upgrade pip && \
+    pip install --no-cache-dir -r requirements.txt
+
+# Copy project files
+COPY --chown=user . .
+
+# Expose port 7860 for Hugging Face Spaces
+EXPOSE 7860
+
+ENV PYTHONUNBUFFERED=1
+
+# Run uvicorn
+CMD ["uvicorn", "app:app", "--host", "0.0.0.0", "--port", "7860"]

hf_space_deployment/README.md

@@ -0,0 +1,114 @@
+---
+title: LITVISION Summarization API
+emoji: 📚
+colorFrom: blue
+colorTo: purple
+sdk: docker
+pinned: false
+license: mit
+---
+
+# LITVISION Book Summarization API
+
+A production-ready FastAPI endpoint for the LITVISION Book Summarization Feature. This service accepts PDF or TXT files, extracts text (using native extraction with OCR fallback for scanned pages), chunks the text smartly, and generates both per-chapter summaries and a final organized summary using `facebook/bart-large-cnn`.
+
+It is fully configured for deployment on Hugging Face Spaces (Docker).
+
+## Features
+
+- **Text Extraction:** Native PDF text extraction using `PyMuPDF`.
+- **OCR Fallback:** Scans unextractable PDF pages using `pytesseract` (supports English and Arabic).
+- **Smart Chunking:** Token-aware sentence grouping to prevent cutting mid-sentence.
+- **Generative AI:** Uses `BART-large-CNN` on GPU (or CPU fallback) with FP16 optimization.
+- **FastAPI Backend:** Fully async HTTP endpoint for file uploads.
+- **Hugging Face Ready:** Pre-configured `Dockerfile` with non-root user and correct port mappings.
+
+## API Endpoints
+
+### `GET /`
+Returns basic API information.
+
+### `GET /health`
+Returns health status.
+```json
+{
+  "status": "healthy",
+  "model_loaded": true,
+  "device": "cuda"
+}
+```
+
+### `POST /summarize`
+Accepts a PDF or TXT file via `multipart/form-data`.
+
+**Request:**
+```bash
+curl -X POST -F "file=@book.pdf" http://localhost:7860/summarize
+```
+
+**Response Format:**
+```json
+{
+  "success": true,
+  "file_name": "book.pdf",
+  "num_chapters": 1,
+  "chapter_summaries": [
+    {
+      "chapter": "BOOK",
+      "summary": "..."
+    }
+  ],
+  "final_summary": "..."
+}
+```
+
+## Folder Structure
+
+```
+.
+├── app.py                # FastAPI endpoints and startup events
+├── summarizer.py         # AI generation logic (BART model)
+├── utils.py              # PDF extraction, OCR, and chunking tools
+├── requirements.txt      # Python dependencies
+├── Dockerfile            # Container configuration
+├── .dockerignore
+├── .gitignore
+└── README.md
+```
+
+## Local Development
+
+### 1. Install System Dependencies (Linux/macOS)
+Make sure you have Tesseract and Poppler installed:
+- **Ubuntu:** `sudo apt-get install poppler-utils tesseract-ocr tesseract-ocr-eng tesseract-ocr-ara`
+- **Mac:** `brew install poppler tesseract tesseract-lang`
+
+### 2. Install Python Dependencies
+```bash
+pip install -r requirements.txt
+```
+
+### 3. Run the Server
+```bash
+uvicorn app:app --host 0.0.0.0 --port 7860 --reload
+```
+
+## Docker Build & Run (Local)
+
+```bash
+docker build -t litvision-summarizer .
+docker run -p 7860:7860 --gpus all litvision-summarizer
+```
+*(Remove `--gpus all` if running on CPU)*
+
+## Deployment to Hugging Face Spaces
+
+1. Go to Hugging Face and create a new Space.
+2. Select **Docker** as the Space SDK.
+3. Upload all the files in this directory directly to the repository.
+4. The space will automatically build the container and start the Uvicorn server on port 7860.
+
+## Troubleshooting
+
+- **CUDA OOM Errors:** Ensure the uploaded book is not excessively long, or adjust the `BATCH_SIZE` in `summarizer.py`.
+- **OCR Not Working:** Verify Tesseract language packs (`tesseract-ocr-ara` and `tesseract-ocr-eng`) are correctly installed in your environment.

hf_space_deployment/app.py

@@ -0,0 +1,133 @@
+import os
+import tempfile
+import logging
+import asyncio
+import torch
+from fastapi import FastAPI, File, UploadFile, HTTPException, BackgroundTasks
+from fastapi.middleware.cors import CORSMiddleware
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+from typing import List
+
+from utils import extract_text_from_file, split_into_chapters
+from summarizer import summarizer, CHAPTER_MIN_NEW_TOKENS_FLOOR, CHAPTER_MAX_NEW_TOKENS_CAP
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+app = FastAPI(
+    title="LITVISION Book Summarization API",
+    description="Extracts text from PDFs/TXTs, chunks, and generates chapter/final summaries.",
+    version="1.0.0"
+)
+
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+
+
+@app.get("/")
+async def root():
+    return {
+        "api": "LITVISION Book Summarization API",
+        "status": "online",
+        "endpoints": ["/health", "/summarize"]
+    }
+
+@app.get("/health")
+async def health():
+    return {
+        "status": "healthy",
+        "model_loaded": summarizer.model is not None,
+        "device": summarizer.device
+    }
+
+class ChapterSummary(BaseModel):
+    chapter: str
+    summary: str
+
+class SummarizationResponse(BaseModel):
+    success: bool
+    file_name: str
+    num_chapters: int
+    chapter_summaries: List[ChapterSummary]
+    final_summary: str
+
+def remove_temp_file(path: str):
+    try:
+        if os.path.exists(path):
+            os.remove(path)
+            logger.info(f"Deleted temp file: {path}")
+    except Exception as e:
+        logger.error(f"Error deleting temp file {path}: {e}")
+
+@app.post("/summarize", response_model=SummarizationResponse)
+async def summarize_endpoint(background_tasks: BackgroundTasks, file: UploadFile = File(...)):
+    if not file.filename.lower().endswith(('.pdf', '.txt')):
+        raise HTTPException(status_code=400, detail="Invalid file type. Only .pdf and .txt are supported.")
+
+    temp_file_path = ""
+    try:
+        suffix = os.path.splitext(file.filename)[1]
+        with tempfile.NamedTemporaryFile(delete=False, suffix=suffix) as temp_file:
+            content = await file.read()
+            if not content:
+                raise HTTPException(status_code=400, detail="Empty file provided.")
+            if len(content) > 50 * 1024 * 1024:
+                raise HTTPException(status_code=413, detail="File too large. Max size is 50MB.")
+            temp_file.write(content)
+            temp_file_path = temp_file.name
+
+        logger.info(f"Extracting text from {file.filename}...")
+        text = await asyncio.to_thread(extract_text_from_file, temp_file_path)
+        
+        if not text.strip():
+            raise HTTPException(status_code=422, detail="Could not extract any text from the file.")
+
+        logger.info("Splitting into chapters...")
+        chapters = split_into_chapters(text)
+        
+        chapter_summaries_result = []
+        raw_chapter_summaries = []
+
+        logger.info(f"Generating summaries for {len(chapters)} chapters...")
+        for title, body in chapters:
+            if not body.strip():
+                continue
+            
+            summ = await asyncio.to_thread(
+                summarizer.summarize_long_text,
+                body,
+                CHAPTER_MIN_NEW_TOKENS_FLOOR,
+                CHAPTER_MAX_NEW_TOKENS_CAP
+            )
+            raw_chapter_summaries.append(summ)
+            chapter_summaries_result.append(ChapterSummary(chapter=title, summary=summ))
+
+        logger.info("Generating final organized summary...")
+        final_summary = await asyncio.to_thread(summarizer.make_big_book_summary, raw_chapter_summaries)
+
+        return SummarizationResponse(
+            success=True,
+            file_name=file.filename,
+            num_chapters=len(chapter_summaries_result),
+            chapter_summaries=chapter_summaries_result,
+            final_summary=final_summary
+        )
+
+    except Exception as e:
+        logger.error(f"Error during summarization: {e}")
+        error_msg = str(e).lower()
+        if isinstance(e, torch.cuda.OutOfMemoryError) or "out of memory" in error_msg:
+            if torch.cuda.is_available():
+                torch.cuda.empty_cache()
+            raise HTTPException(status_code=500, detail="CUDA out of memory. Try a smaller file.")
+        raise HTTPException(status_code=500, detail=str(e))
+    finally:
+        if temp_file_path:
+            background_tasks.add_task(remove_temp_file, temp_file_path)

hf_space_deployment/requirements.txt

@@ -0,0 +1,12 @@
+fastapi>=0.100.0
+uvicorn>=0.23.0
+python-multipart>=0.0.6
+transformers>=4.33.0
+torch>=2.0.0
+pymupdf>=1.23.0
+pdf2image>=1.16.3
+pytesseract>=0.3.10
+Pillow>=10.0.0
+tqdm>=4.66.0
+sentencepiece>=0.1.99
+accelerate>=0.23.0

hf_space_deployment/summarizer.py

@@ -0,0 +1,194 @@
+import math
+import logging
+import torch
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+from utils import iter_paragraphs, split_sentences, normalize_text
+
+logger = logging.getLogger(__name__)
+
+# Model config
+MODEL_NAME = "facebook/bart-large-cnn"
+BATCH_SIZE = 4
+NUM_BEAMS = 4
+NO_REPEAT_NGRAM_SIZE = 3
+EARLY_STOPPING = False
+
+# Chunking config
+MAX_INPUT_TOKENS = 1024
+HEADROOM_TOKENS = 16
+EFFECTIVE_MAX_INPUT = MAX_INPUT_TOKENS - HEADROOM_TOKENS
+OVERLAP_SENTENCES = 2
+
+# Output size caps
+CHAPTER_MAX_NEW_TOKENS_CAP = 320
+CHAPTER_MIN_NEW_TOKENS_FLOOR = 120
+BOOK_PARTS = 8
+
+class BookSummarizer:
+    def __init__(self):
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.tokenizer = None
+        self.model = None
+
+    def load_model(self):
+        """Loads the tokenizer and model into memory."""
+        if self.model is not None:
+            return
+            
+        logger.info(f"Loading model {MODEL_NAME} onto {self.device}...")
+        self.tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_fast=True)
+        self.model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(self.device)
+        
+        if self.device == "cuda":
+            try:
+                self.model.half()
+            except Exception as e:
+                logger.warning(f"Could not convert model to fp16: {e}")
+                
+        self.model.eval()
+        logger.info("Model loaded successfully.")
+
+    def tok_len(self, s: str) -> int:
+        return len(self.tokenizer.encode(s, add_special_tokens=False))
+
+    def split_by_tokens(self, s: str, max_len: int, overlap_tokens: int = 64):
+        ids = self.tokenizer.encode(s, add_special_tokens=False)
+        if len(ids) <= max_len:
+            return [s.strip()]
+        overlap_tokens = max(0, min(overlap_tokens, max_len // 3))
+        step = max(1, max_len - overlap_tokens)
+        parts = []
+        for i in range(0, len(ids), step):
+            chunk_ids = ids[i:i+max_len]
+            if not chunk_ids:
+                continue
+            t = self.tokenizer.decode(chunk_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True).strip()
+            if t:
+                parts.append(t)
+        return parts
+
+    def chunk_text(self, text: str, max_input_tokens: int = EFFECTIVE_MAX_INPUT, overlap_sentences: int = OVERLAP_SENTENCES):
+        text = normalize_text(text)
+        if not text:
+            return []
+
+        chunks = []
+        cur_sents, cur_tok = [], 0
+
+        def flush():
+            nonlocal cur_sents, cur_tok
+            if cur_sents:
+                ch = " ".join(cur_sents).strip()
+                if ch:
+                    chunks.append(ch)
+            cur_sents, cur_tok = [], 0
+
+        for para in iter_paragraphs(text):
+            for sent in split_sentences(para):
+                st = sent.strip()
+                if not st:
+                    continue
+                st_tok = self.tok_len(st)
+
+                if st_tok > max_input_tokens:
+                    flush()
+                    chunks.extend(self.split_by_tokens(st, max_len=max_input_tokens, overlap_tokens=64))
+                    continue
+
+                if cur_tok + st_tok <= max_input_tokens:
+                    cur_sents.append(st)
+                    cur_tok += st_tok
+                else:
+                    prev = cur_sents[:]
+                    flush()
+                    overlap = prev[-overlap_sentences:] if overlap_sentences and prev else []
+                    cur_sents = overlap + [st]
+                    cur_tok = self.tok_len(" ".join(cur_sents))
+
+        flush()
+        return chunks
+
+    @torch.no_grad()
+    def generate_summaries(self, texts, min_new_tokens, max_new_tokens, batch_size=BATCH_SIZE):
+        if not self.model:
+            self.load_model()
+            
+        outs = []
+        for i in range(0, len(texts), batch_size):
+            batch = texts[i:i+batch_size]
+            enc = self.tokenizer(
+                batch, return_tensors="pt",
+                truncation=True, padding=True,
+                max_length=EFFECTIVE_MAX_INPUT
+            ).to(self.device)
+
+            try:
+                gen = self.model.generate(
+                    **enc,
+                    num_beams=NUM_BEAMS,
+                    no_repeat_ngram_size=NO_REPEAT_NGRAM_SIZE,
+                    min_new_tokens=min_new_tokens,
+                    max_new_tokens=max_new_tokens,
+                    early_stopping=EARLY_STOPPING,
+                )
+            except TypeError:
+                gen = self.model.generate(
+                    **enc,
+                    num_beams=NUM_BEAMS,
+                    no_repeat_ngram_size=NO_REPEAT_NGRAM_SIZE,
+                    min_length=min_new_tokens,
+                    max_length=max_new_tokens,
+                    early_stopping=EARLY_STOPPING,
+                )
+
+            decoded = self.tokenizer.batch_decode(gen, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+            outs.extend([d.strip() for d in decoded])
+        return outs
+
+    def summarize_long_text(self, text: str, min_new: int, max_new: int):
+        chunks = self.chunk_text(text)
+        if not chunks:
+            return ""
+
+        chunk_summaries = []
+        for ch in chunks:
+            tlen = self.tok_len(ch)
+            dyn_max = int(min(max_new, max(min_new, round(tlen * 0.18))))
+            dyn_min = max(30, min(min_new, dyn_max - 10))
+            chunk_summaries.append(self.generate_summaries([ch], dyn_min, dyn_max, batch_size=1)[0])
+
+        if len(chunk_summaries) == 1:
+            return chunk_summaries[0]
+
+        current = chunk_summaries
+        for _ in range(6):
+            combined = "\n".join([f"Part {i+1}: {t}" for i, t in enumerate(current)])
+            if self.tok_len(combined) <= EFFECTIVE_MAX_INPUT:
+                return self.generate_summaries([combined], min_new, max_new, batch_size=1)[0]
+
+            sub_chunks = self.chunk_text(combined, overlap_sentences=1)
+            current = self.generate_summaries(
+                sub_chunks,
+                min_new_tokens=max(60, min_new // 2),
+                max_new_tokens=max(180, max_new // 2),
+                batch_size=BATCH_SIZE
+            )
+        return "\n".join(current).strip()
+
+    def make_big_book_summary(self, chapter_summaries, parts=BOOK_PARTS):
+        chap_summaries = [s for s in chapter_summaries if s.strip()]
+        if not chap_summaries:
+            return ""
+
+        n = len(chap_summaries)
+        group_size = max(1, math.ceil(n / parts))
+        groups = [chap_summaries[i:i+group_size] for i in range(0, n, group_size)]
+
+        part_summaries = []
+        for gi, g in enumerate(groups):
+            combined = "\n".join([f"ChapterSummary {gi+1}.{i+1}: {t}" for i, t in enumerate(g)])
+            ps = self.summarize_long_text(combined, min_new=220, max_new=520)
+            part_summaries.append(ps.strip())
+        return "\n\n".join(part_summaries)
+
+summarizer = BookSummarizer()

hf_space_deployment/utils.py

@@ -0,0 +1,126 @@
+import os
+import re
+from pathlib import Path
+from typing import List, Tuple
+
+import fitz  # pymupdf
+from pdf2image import convert_from_path
+import pytesseract
+from PIL import ImageOps, ImageEnhance
+
+OCR_LANG = "eng+ara"
+OCR_DPI = 180
+NATIVE_MIN_CHARS_PER_PAGE = 60  # if native extracted text < this => OCR that page
+
+_SENT_BOUNDARY_RE = re.compile(r"(?<=[\.\!\?\u061F\u06D4\u061B…])\s+")  # . ! ? ؟ ۔ ؛ …
+
+def normalize_text(text: str) -> str:
+    """Normalizes text by removing excessive whitespace and fixing newlines."""
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+def ocr_image_pil(img):
+    """Applies light preprocessing to improve OCR accuracy."""
+    img = img.convert("RGB")
+    img = ImageOps.grayscale(img)
+    img = ImageEnhance.Contrast(img).enhance(1.6)
+    return img
+
+def ocr_pdf_page(pdf_path: str, page_number_1based: int, dpi: int = OCR_DPI, lang: str = OCR_LANG) -> str:
+    """OCRs a single PDF page."""
+    images = convert_from_path(
+        str(pdf_path),
+        dpi=dpi,
+        first_page=page_number_1based,
+        last_page=page_number_1based,
+        fmt="png",
+        thread_count=2,
+    )
+    if not images:
+        return ""
+    img = images[0]
+    img = ocr_image_pil(img)
+    return pytesseract.image_to_string(img, lang=lang)
+
+def pdf_to_text_smart(pdf_path: str, native_min_chars_per_page: int = NATIVE_MIN_CHARS_PER_PAGE) -> str:
+    """Extracts text from PDF, falling back to OCR for scanned pages."""
+    doc = fitz.open(str(pdf_path))
+    parts = []
+
+    for i in range(doc.page_count):
+        page = doc.load_page(i)
+        native = (page.get_text("text") or "").strip()
+        native_compact_len = len(re.sub(r"\s+", "", native))
+
+        if native_compact_len >= native_min_chars_per_page:
+            parts.append(native)
+        else:
+            ocr = ocr_pdf_page(pdf_path, page_number_1based=i+1)
+            parts.append(ocr)
+
+    doc.close()
+    return normalize_text("\n\n".join(parts))
+
+def extract_text_from_file(file_path: str) -> str:
+    """Extracts text from a .txt or .pdf file."""
+    path = Path(file_path)
+    suf = path.suffix.lower()
+
+    if suf == ".txt":
+        raw = path.read_text(encoding="utf-8", errors="ignore")
+        return normalize_text(raw)
+    
+    if suf == ".pdf":
+        return pdf_to_text_smart(str(path))
+        
+    raise ValueError(f"Unsupported file type '{suf}'. Please upload .pdf or .txt only.")
+
+def split_into_chapters(text: str) -> List[Tuple[str, str]]:
+    """
+    Best effort chapter split:
+    - Detect lines that look like: CHAPTER 1 / Chapter One / CHAPTER ONE etc.
+    - If not found, return one chapter = full text.
+    Returns: list of (title, body)
+    """
+    text = normalize_text(text)
+    lines = text.splitlines()
+
+    chapter_re = re.compile(r"^\s*(chapter|CHAPTER)\s+([0-9]+|[IVXLC]+|[A-Za-z]+)\b.*$", re.IGNORECASE)
+
+    idxs = []
+    titles = []
+    for i, ln in enumerate(lines):
+        if chapter_re.match(ln.strip()):
+            idxs.append(i)
+            titles.append(ln.strip())
+
+    if len(idxs) < 2:
+        return [("BOOK", text)]
+
+    chapters = []
+    for k in range(len(idxs)):
+        start = idxs[k]
+        end = idxs[k+1] if k+1 < len(idxs) else len(lines)
+        title = titles[k]
+        body = "\n".join(lines[start:end]).strip()
+        chapters.append((title, body))
+    return chapters
+
+def split_sentences(paragraph: str) -> List[str]:
+    """Splits a paragraph into sentences."""
+    paragraph = paragraph.strip()
+    if not paragraph:
+        return []
+    if not any(ch in paragraph for ch in ".!?\u061F\u06D4\u061B…"):
+        ls = [ln.strip() for ln in paragraph.split("\n") if ln.strip()]
+        return ls if ls else [paragraph]
+    return [s.strip() for s in _SENT_BOUNDARY_RE.split(paragraph) if s.strip()]
+
+def iter_paragraphs(text: str):
+    """Yields paragraphs from text."""
+    for p in re.split(r"\n\s*\n+", text):
+        p = p.strip()
+        if p:
+            yield p

notebook_code.py

@@ -0,0 +1,458 @@
+# =========================
+# Cell 1 — Install deps (Colab)
+# =========================
+!apt-get -qq update
+!apt-get -qq install -y poppler-utils tesseract-ocr tesseract-ocr-eng tesseract-ocr-ara
+!pip -q install -U transformers accelerate sentencepiece pymupdf pdf2image pytesseract pillow tqdm
+# =========================
+# Cell 2 — Imports + Config
+# =========================
+import os, re, json
+from pathlib import Path
+from math import ceil
+
+import torch
+from tqdm.auto import tqdm
+
+import fitz  # pymupdf
+from pdf2image import convert_from_path
+import pytesseract
+from PIL import ImageOps, ImageEnhance
+
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
+
+OUTPUT_DIR = Path("/content/output")
+OUTPUT_DIR.mkdir(parents=True, exist_ok=True)
+
+# Model (English-focused)
+MODEL_NAME = "facebook/bart-large-cnn"  # https://huggingface.co/facebook/bart-large-cnn
+
+# OCR
+OCR_LANG = "eng+ara"
+OCR_DPI = 250
+NATIVE_MIN_CHARS_PER_PAGE = 60  # if native extracted text < this => OCR that page
+
+# Summarization quality/speed knobs
+BATCH_SIZE = 4
+NUM_BEAMS = 4
+NO_REPEAT_NGRAM_SIZE = 3
+EARLY_STOPPING = False
+
+# Chunking
+MAX_INPUT_TOKENS = 1024
+HEADROOM_TOKENS = 16
+EFFECTIVE_MAX_INPUT = MAX_INPUT_TOKENS - HEADROOM_TOKENS
+OVERLAP_SENTENCES = 2
+
+# Output size (big + محترم)
+CHAPTER_MAX_NEW_TOKENS_CAP = 320   # max tokens generated per chapter summary
+CHAPTER_MIN_NEW_TOKENS_FLOOR = 120
+BOOK_PARTS = 8  # final organized "big" summary in N parts
+
+device = "cuda" if torch.cuda.is_available() else "cpu"
+print("Device:", device)
+print("Output folder:", OUTPUT_DIR)
+# =========================
+# Cell 3 — Upload input (PDF or TXT)
+# =========================
+from google.colab import files
+
+uploaded = files.upload()
+INPUT_PATH = Path(next(iter(uploaded.keys()))).resolve()
+
+print("Uploaded:", INPUT_PATH)
+print("Suffix:", INPUT_PATH.suffix.lower())
+# =========================
+# Cell 4 — PDF/TXT -> Clean TXT (robust native + per-page OCR fallback)
+# =========================
+_SENT_BOUNDARY_RE = re.compile(r"(?<=[\.\!\?\u061F\u06D4\u061B…])\s+")  # . ! ? ؟ ۔ ؛ …
+
+def normalize_text(text: str) -> str:
+    text = text.replace("\r\n", "\n").replace("\r", "\n")
+    text = re.sub(r"[ \t]+", " ", text)
+    text = re.sub(r"\n{3,}", "\n\n", text)
+    return text.strip()
+
+def ocr_image_pil(img):
+    # Light preprocessing to improve OCR
+    img = img.convert("RGB")
+    img = ImageOps.grayscale(img)
+    img = ImageEnhance.Contrast(img).enhance(1.6)
+    return img
+
+def ocr_pdf_page(pdf_path: Path, page_number_1based: int, dpi: int = OCR_DPI, lang: str = OCR_LANG) -> str:
+    images = convert_from_path(
+        str(pdf_path),
+        dpi=dpi,
+        first_page=page_number_1based,
+        last_page=page_number_1based,
+        fmt="png",
+        thread_count=2,
+    )
+    img = images[0]
+    img = ocr_image_pil(img)
+    return pytesseract.image_to_string(img, lang=lang)
+
+def pdf_to_text_smart(pdf_path: Path,
+                     native_min_chars_per_page: int = NATIVE_MIN_CHARS_PER_PAGE) -> str:
+    doc = fitz.open(str(pdf_path))
+    parts = []
+
+    for i in tqdm(range(doc.page_count), desc="Extracting pages"):
+        page = doc.load_page(i)
+        native = (page.get_text("text") or "").strip()
+        native_compact_len = len(re.sub(r"\s+", "", native))
+
+        if native_compact_len >= native_min_chars_per_page:
+            parts.append(native)
+        else:
+            ocr = ocr_pdf_page(pdf_path, page_number_1based=i+1)
+            parts.append(ocr)
+
+    doc.close()
+    return normalize_text("\n\n".join(parts))
+
+def ensure_txt(input_path: Path) -> Path:
+    out_txt = OUTPUT_DIR / f"{input_path.stem}.txt"
+    suf = input_path.suffix.lower()
+
+    if suf == ".txt":
+        raw = input_path.read_text(encoding="utf-8", errors="ignore")
+        out_txt.write_text(normalize_text(raw), encoding="utf-8")
+        return out_txt
+
+    if suf == ".pdf":
+        text = pdf_to_text_smart(input_path)
+        out_txt.write_text(text, encoding="utf-8")
+        return out_txt
+
+    raise ValueError("Unsupported type. Upload .pdf or .txt only.")
+
+BOOK_TXT_PATH = ensure_txt(INPUT_PATH)
+BOOK_TEXT = BOOK_TXT_PATH.read_text(encoding="utf-8", errors="ignore")
+
+print("Saved TXT:", BOOK_TXT_PATH)
+print("Chars:", len(BOOK_TEXT))
+print("Head preview:\n", BOOK_TEXT[:800])
+# FIX Pillow broken install (PIL._typing/_Ink issue)
+!pip -q uninstall -y Pillow pillow-simd
+!pip -q install --no-cache-dir --force-reinstall "Pillow==10.4.0"
+
+import PIL, sys
+print("Pillow version:", PIL.__version__)
+print("Python:", sys.version)
+# =========================
+# Cell 5 — Load tokenizer + model (from Hugging Face)
+# =========================
+tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME, use_fast=True)
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME).to(device)
+
+if device == "cuda":
+    try:
+        model.half()
+    except Exception:
+        pass
+
+torch.set_grad_enabled(False)
+print("Model loaded:", MODEL_NAME)
+# =========================
+# Cell 6 — Chapter splitting + token-aware chunking
+# =========================
+def split_into_chapters(text: str):
+    """
+    Best effort chapter split:
+    - Detect lines that look like: CHAPTER 1 / Chapter One / CHAPTER ONE etc.
+    - If not found, return one chapter = full text.
+    """
+    text = normalize_text(text)
+    lines = text.splitlines()
+
+    chapter_re = re.compile(r"^\s*(chapter|CHAPTER)\s+([0-9]+|[IVXLC]+|[A-Za-z]+)\b.*$", re.IGNORECASE)
+
+    idxs = []
+    titles = []
+    for i, ln in enumerate(lines):
+        if chapter_re.match(ln.strip()):
+            idxs.append(i)
+            titles.append(ln.strip())
+
+    if len(idxs) < 2:
+        return [("BOOK", text)]
+
+    chapters = []
+    for k in range(len(idxs)):
+        start = idxs[k]
+        end = idxs[k+1] if k+1 < len(idxs) else len(lines)
+        title = titles[k]
+        body = "\n".join(lines[start:end]).strip()
+        chapters.append((title, body))
+    return chapters
+
+def split_sentences(paragraph: str):
+    paragraph = paragraph.strip()
+    if not paragraph:
+        return []
+    if not any(ch in paragraph for ch in ".!?\u061F\u06D4\u061B…"):
+        ls = [ln.strip() for ln in paragraph.split("\n") if ln.strip()]
+        return ls if ls else [paragraph]
+    return [s.strip() for s in _SENT_BOUNDARY_RE.split(paragraph) if s.strip()]
+
+def iter_paragraphs(text: str):
+    for p in re.split(r"\n\s*\n+", text):
+        p = p.strip()
+        if p:
+            yield p
+
+def tok_len(s: str) -> int:
+    return len(tokenizer.encode(s, add_special_tokens=False))
+
+def split_by_tokens(s: str, max_len: int, overlap_tokens: int = 64):
+    ids = tokenizer.encode(s, add_special_tokens=False)
+    if len(ids) <= max_len:
+        return [s.strip()]
+    overlap_tokens = max(0, min(overlap_tokens, max_len // 3))
+    step = max(1, max_len - overlap_tokens)
+    parts = []
+    for i in range(0, len(ids), step):
+        chunk_ids = ids[i:i+max_len]
+        if not chunk_ids:
+            continue
+        t = tokenizer.decode(chunk_ids, skip_special_tokens=True, clean_up_tokenization_spaces=True).strip()
+        if t:
+            parts.append(t)
+    return parts
+
+def chunk_text(text: str, max_input_tokens: int = EFFECTIVE_MAX_INPUT, overlap_sentences: int = OVERLAP_SENTENCES):
+    """
+    Professional chunking:
+    - pack sentences under token limit
+    - add sentence overlap between chunks for continuity
+    - if a single sentence is too long => token-split it
+    """
+    text = normalize_text(text)
+    if not text:
+        return []
+
+    chunks = []
+    cur_sents, cur_tok = [], 0
+
+    def flush():
+        nonlocal cur_sents, cur_tok
+        if cur_sents:
+            ch = " ".join(cur_sents).strip()
+            if ch:
+                chunks.append(ch)
+        cur_sents, cur_tok = [], 0
+
+    for para in iter_paragraphs(text):
+        for sent in split_sentences(para):
+            st = sent.strip()
+            if not st:
+                continue
+            st_tok = tok_len(st)
+
+            if st_tok > max_input_tokens:
+                flush()
+                chunks.extend(split_by_tokens(st, max_len=max_input_tokens, overlap_tokens=64))
+                continue
+
+            if cur_tok + st_tok <= max_input_tokens:
+                cur_sents.append(st)
+                cur_tok += st_tok
+            else:
+                prev = cur_sents[:]
+                flush()
+                overlap = prev[-overlap_sentences:] if overlap_sentences and prev else []
+                cur_sents = overlap + [st]
+                cur_tok = tok_len(" ".join(cur_sents))
+
+    flush()
+    return chunks
+# =========================
+# Cell 7 — Summarization helpers (map -> reduce) + "organized big summary"
+# =========================
+@torch.no_grad()
+def generate_summaries(texts, min_new_tokens, max_new_tokens, batch_size=BATCH_SIZE):
+    outs = []
+    for i in range(0, len(texts), batch_size):
+        batch = texts[i:i+batch_size]
+        enc = tokenizer(
+            batch, return_tensors="pt",
+            truncation=True, padding=True,
+            max_length=EFFECTIVE_MAX_INPUT
+        ).to(device)
+
+        try:
+            gen = model.generate(
+                **enc,
+                num_beams=NUM_BEAMS,
+                no_repeat_ngram_size=NO_REPEAT_NGRAM_SIZE,
+                min_new_tokens=min_new_tokens,
+                max_new_tokens=max_new_tokens,
+                early_stopping=EARLY_STOPPING,
+            )
+        except TypeError:
+            # fallback for older transformers
+            gen = model.generate(
+                **enc,
+                num_beams=NUM_BEAMS,
+                no_repeat_ngram_size=NO_REPEAT_NGRAM_SIZE,
+                min_length=min_new_tokens,
+                max_length=max_new_tokens,
+                early_stopping=EARLY_STOPPING,
+            )
+
+        decoded = tokenizer.batch_decode(gen, skip_special_tokens=True, clean_up_tokenization_spaces=True)
+        outs.extend([d.strip() for d in decoded])
+    return outs
+
+def summarize_long_text(text: str, min_new: int, max_new: int):
+    """
+    Summarize very long text reliably:
+    - chunk -> summarize each chunk
+    - if multiple chunk summaries, reduce them into one (still ordered)
+    """
+    chunks = chunk_text(text)
+    if not chunks:
+        return ""
+
+    # summarize chunks
+    chunk_summaries = []
+    for ch in chunks:
+        tlen = tok_len(ch)
+        # dynamic summary size per chunk (keeps it detailed)
+        dyn_max = int(min(max_new, max(min_new, round(tlen * 0.18))))
+        dyn_min = max(30, min(min_new, dyn_max - 10))
+        chunk_summaries.append(generate_summaries([ch], dyn_min, dyn_max, batch_size=1)[0])
+
+    if len(chunk_summaries) == 1:
+        return chunk_summaries[0]
+
+    # reduce in groups (keeps order)
+    current = chunk_summaries
+    for _ in range(6):
+        combined = "\n".join([f"Part {i+1}: {t}" for i, t in enumerate(current)])
+        if tok_len(combined) <= EFFECTIVE_MAX_INPUT:
+            return generate_summaries([combined], min_new, max_new, batch_size=1)[0]
+
+        # too long -> chunk combined summaries and summarize each chunk
+        sub_chunks = chunk_text(combined, overlap_sentences=1)
+        current = generate_summaries(
+            sub_chunks,
+            min_new_tokens=max(60, min_new // 2),
+            max_new_tokens=max(180, max_new // 2),
+            batch_size=BATCH_SIZE
+        )
+    return "\n".join(current).strip()
+
+def make_big_book_summary(chapter_summaries, parts=BOOK_PARTS):
+    """
+    Organized "big" summary:
+    - group chapter summaries into N parts
+    - summarize each group into a longer part-summary
+    - output stays structured and chronological
+    """
+    chap_summaries = [s for s in chapter_summaries if s.strip()]
+    if not chap_summaries:
+        return []
+
+    n = len(chap_summaries)
+    group_size = max(1, ceil(n / parts))
+    groups = [chap_summaries[i:i+group_size] for i in range(0, n, group_size)]
+
+    part_summaries = []
+    for gi, g in enumerate(tqdm(groups, desc="Building big organized summary")):
+        combined = "\n".join([f"ChapterSummary {gi+1}.{i+1}: {t}" for i, t in enumerate(g)])
+        ps = summarize_long_text(combined, min_new=220, max_new=520)
+        part_summaries.append(ps.strip())
+    return part_summaries
+# =========================
+# Cell 8 — RUN: chapter summaries + big organized summary + save all outputs
+# =========================
+chapters = split_into_chapters(BOOK_TEXT)
+print("Detected chapters:", len(chapters))
+print("First chapter title:", chapters[0][0])
+
+# Save chapters as separate txt files (for debugging)
+chapters_dir = OUTPUT_DIR / f"{BOOK_TXT_PATH.stem}_chapters"
+chapters_dir.mkdir(parents=True, exist_ok=True)
+
+chapter_summaries = []
+chapter_meta = []
+
+for idx, (title, body) in enumerate(tqdm(chapters, desc="Summarizing chapters")):
+    safe_title = re.sub(r"[^A-Za-z0-9 _-]+", "", title)[:80].strip().replace(" ", "_")
+    ch_txt_path = chapters_dir / f"{idx+1:03d}_{safe_title or 'CHAPTER'}.txt"
+    ch_txt_path.write_text(body, encoding="utf-8")
+
+    # chapter summary (detailed)
+    # (إذا الفصل طويل جدًا summarize_long_text هيعمل chunking داخليًا)
+    summary = summarize_long_text(
+        body,
+        min_new=CHAPTER_MIN_NEW_TOKENS_FLOOR,
+        max_new=CHAPTER_MAX_NEW_TOKENS_CAP
+    )
+
+    chapter_summaries.append(summary)
+    chapter_meta.append({"index": idx+1, "title": title, "txt_path": str(ch_txt_path)})
+
+# 1) Save per-chapter summaries (organized)
+chapter_summaries_path = OUTPUT_DIR / f"{BOOK_TXT_PATH.stem}.chapter_summaries.txt"
+with chapter_summaries_path.open("w", encoding="utf-8") as f:
+    for i, (meta, summ) in enumerate(zip(chapter_meta, chapter_summaries), start=1):
+        f.write(f"===== CHAPTER {i}: {meta['title']} =====\n")
+        f.write(summ.strip() + "\n\n")
+
+# 2) Save "big organized book summary" (multi-part, محترم وكبير)
+big_parts = make_big_book_summary(chapter_summaries, parts=BOOK_PARTS)
+big_summary_path = OUTPUT_DIR / f"{BOOK_TXT_PATH.stem}.BIG_book_summary_parts.txt"
+big_summary_path.write_text(
+    "\n\n".join([f"=== BOOK SUMMARY PART {i+1} ===\n{p}" for i, p in enumerate(big_parts)]),
+    encoding="utf-8"
+)
+
+# 3) Also save a single-file "full" summary by concatenating chapter summaries (very long, but super clear)
+full_concat_path = OUTPUT_DIR / f"{BOOK_TXT_PATH.stem}.FULL_chapter_summaries_concat.txt"
+full_concat_path.write_text("\n\n".join(chapter_summaries), encoding="utf-8")
+
+# 4) Metadata
+meta_path = OUTPUT_DIR / f"{BOOK_TXT_PATH.stem}.meta.json"
+meta_path.write_text(json.dumps({
+    "input_file": str(INPUT_PATH),
+    "book_txt": str(BOOK_TXT_PATH),
+    "model": MODEL_NAME,
+    "device": device,
+    "chapters_detected": len(chapters),
+    "chapter_files_dir": str(chapters_dir),
+    "outputs": {
+        "chapter_summaries": str(chapter_summaries_path),
+        "big_book_summary_parts": str(big_summary_path),
+        "full_concat": str(full_concat_path),
+    }
+}, ensure_ascii=False, indent=2), encoding="utf-8")
+
+print("\nSaved outputs:")
+print(" - Chapter summaries:", chapter_summaries_path)
+print(" - BIG organized parts:", big_summary_path)
+print(" - FULL concat:", full_concat_path)
+print(" - Meta:", meta_path)
+
+print("\nPreview BIG summary part 1:\n")
+print(big_parts[0][:1500] if big_parts else "N/A")
+# =========================
+# Cell 9 — Save model + zip outputs + download
+# =========================
+saved_model_dir = OUTPUT_DIR / "saved_model_bart_large_cnn"
+saved_model_dir.mkdir(parents=True, exist_ok=True)
+
+model.save_pretrained(saved_model_dir)
+tokenizer.save_pretrained(saved_model_dir)
+
+print("Model saved to:", saved_model_dir)
+
+zip_path = Path("/content/litvision_output.zip")
+!zip -qr "{zip_path}" "{OUTPUT_DIR}"
+print("Zipped to:", zip_path)
+
+from google.colab import files
+files.download(str(zip_path))