Update app.py

app.py

@@ -1,34 +1,22 @@
 import gradio as gr
-import fitz  # PyMuPDF
+import fitz
 import torch
 from transformers import pipeline
 import time, logging, re
 import matplotlib
-matplotlib.use('Agg')
+matplotlib.use('Agg')  # Use non-interactive backend for headless environments
 import matplotlib.pyplot as plt
 import io
 from PIL import Image
-from concurrent.futures import ThreadPoolExecutor
-import numpy as np
 
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
+logging.basicConfig(level=logging.ERROR)
+device = -1  # CPU-only
+print("⚠️ CPU-only. Expect ~20–30s for 300,000 chars.")
 
-# Set device and optimize for speed
-device = 0 if torch.cuda.is_available() else -1
-logger.info(f"🔧 Using {'GPU' if device == 0 else 'CPU'}")
-
-# Load model
 try:
-    summarizer = pipeline(
-        "summarization",
-        model="t5-small",
-        device=device,
-        framework="pt",
-        torch_dtype=torch.float16 if device == 0 else torch.float32
-    )
+    summarizer = pipeline("summarization", model="t5-small", device=device, torch_dtype=torch.float32)
 except Exception as e:
-    logger.error(f"❌ Model loading failed: {str(e)}")
+    print(f"❌ Model loading failed: {str(e)}")
     exit(1)
 
 def visualize_chunk_status(chunk_data):
@@ -37,163 +25,79 @@ def visualize_chunk_status(chunk_data):
     colors = [status_colors.get(i['status'], 'gray') for i in chunk_data]
     times = [i.get('time', 0.1) for i in chunk_data]
 
-    fig, ax = plt.subplots(figsize=(8, 2))
-    ax.barh(labels, times, color=colors, height=0.4)
+    fig, ax = plt.subplots(figsize=(10, 2.5))
+    ax.barh(labels, times, color=colors)
     ax.set_xlabel("Time (s)")
-    ax.set_title("Chunk Status")
-    plt.tight_layout(pad=0.5)
-    buf = io.BytesIO()
-    plt.savefig(buf, format='png', dpi=100)
-    plt.close(fig)
-    buf.seek(0)
-    return Image.open(buf)
+    ax.set_title("📊 Chunk Processing Status")
+    plt.tight_layout()
 
-def create_summary_flowchart(summaries):
-    # Filter valid summaries and extract key points
-    filtered = [
-        s for s in summaries 
-        if s.startswith("**Chunk") and "Skipped" not in s and "Error" not in s
-    ]
-    if not filtered:
-        return None
-
-    # Extract key points (first sentence or most important phrase)
-    key_points = []
-    for summary in filtered:
-        summary_text = summary.split("**Chunk")[1].split("\n", 1)[-1].strip()
-        # Take first sentence or truncate to 50 characters
-        first_sentence = re.split(r'(?<=[.!?])\s+', summary_text)[0][:50]
-        key_points.append(first_sentence + ("..." if len(first_sentence) >= 50 else ""))
-
-    # Create flowchart
-    fig_height = max(1.5, len(key_points) * 0.6)
-    fig, ax = plt.subplots(figsize=(6, fig_height))
-    ax.axis('off')
-
-    # Node positions and styling
-    ypos = np.arange(len(key_points) * 1.2, 0, -1.2)
-    boxprops = dict(boxstyle="round,pad=0.3", facecolor="lightgreen", edgecolor="black", alpha=0.9)
-
-    for i, (y, point) in enumerate(zip(ypos, key_points)):
-        # Draw node with key point
-        ax.text(0.5, y, point, ha='center', va='center', fontsize=9, bbox=boxprops)
-        # Draw arrows between nodes
-        if i < len(key_points) - 1:
-            ax.arrow(0.5, y - 0.3, 0, -0.9, head_width=0.02, head_length=0.1, fc='blue', ec='blue')
-
-    # Add title
-    ax.text(0.5, ypos[0] + 0.8, "Key Points Summary", ha='center', va='center', fontsize=12, weight='bold')
-
-    plt.tight_layout(pad=0.1)
     buf = io.BytesIO()
-    fig.savefig(buf, format='png', dpi=100, bbox_inches='tight')
-    plt.close(fig)
+    plt.savefig(buf, format='png')
     buf.seek(0)
+    plt.close(fig)  # Release memory
     return Image.open(buf)
 
-def process_chunk(i, chunk):
-    chunk_result = {'chunk': i + 1, 'status': '', 'time': 0}
-    start_time = time.time()
-
-    if not chunk.strip() or sum(1 for c in chunk if not c.isalnum()) / len(chunk) > 0.5:
-        result = f"**Chunk {i+1}**: Skipped (empty or equation-heavy)"
-        chunk_result['status'] = 'skipped'
-    else:
-        try:
-            summary = summarizer(chunk, max_length=60, min_length=10, do_sample=False)[0]['summary_text']
-            result = f"**Chunk {i+1}**:\n{summary}"
-            chunk_result['status'] = 'summarized'
-        except Exception as e:
-            result = f"**Chunk {i+1}**: Error: {str(e)}"
-            chunk_result['status'] = 'error'
-
-    chunk_result['time'] = time.time() - start_time
-    return result, chunk_result
-
 def summarize_file(file_bytes):
     start = time.time()
-    summaries = []
     chunk_info = []
 
     try:
         doc = fitz.open(stream=file_bytes, filetype="pdf")
-        text = ""
-        for page in doc:
-            page_text = page.get_text("text")
-            if not page_text.strip():
-                continue
-            text += page_text
-            if len(text) > 30000:
-                text = text[:30000]
-                break
-        doc.close()
-        
-        text = re.sub(r"\$\s*[^$]+\s*\$|\\cap|\s+", lambda m: "intersection" if m.group(0) == "\\cap" else " ", text)
-        text = "".join(c for c in text if ord(c) < 128)[:30000]
+        text = "".join(page.get_text("text") for page in doc)
+        text = re.sub(r"\$\s*([^$]+)\s*\$", r"\1", text)
+        text = re.sub(r"\\cap", "intersection", text)
+        text = re.sub(r"\s+", " ", text).strip()
+        text = "".join(c for c in text if ord(c) < 128)
     except Exception as e:
-        return f"Text extraction failed: {str(e)}", None, None
+        return f"❌ Text extraction failed: {str(e)}", None
 
     if not text.strip():
-        return "No text found", None, None
+        return "❌ No text found", None
 
-    chunks = []
-    current_chunk = ""
-    for sentence in re.split(r'(?<=[.!?])\s+', text):
-        if len(current_chunk) + len(sentence) <= 1000:
-            current_chunk += sentence
-        else:
-            if current_chunk:
-                chunks.append(current_chunk)
-            current_chunk = sentence
-        if len(chunks) >= 30:
+    text = text[:300000]
+    chunks = [text[i:i+2000] for i in range(0, len(text), 2000)]
+    summaries = []
+
+    for i, chunk in enumerate(chunks):
+        chunk_start = time.time()
+        chunk_result = {'chunk': i + 1, 'status': '', 'time': 0}
+
+        if time.time() - start > 20:
+            summaries.append("⚠️ Stopped early")
             break
-    if current_chunk:
-        chunks.append(current_chunk)
 
-    max_workers = min(8, max(2, torch.cuda.device_count() * 4 if device == 0 else 4))
-    with ThreadPoolExecutor(max_workers=max_workers) as executor:
-        results = list(executor.map(lambda ic: process_chunk(*ic), enumerate(chunks)))
+        if sum(1 for c in chunk if not c.isalnum()) / len(chunk) > 0.5:
+            summaries.append(f"**Chunk {i+1}**: Skipped (equation-heavy)")
+            chunk_result['status'] = 'skipped'
+        else:
+            try:
+                summary = summarizer(chunk, max_length=60, min_length=10, do_sample=False)[0]['summary_text']
+                summaries.append(f"**Chunk {i+1}**:\n{summary}")
+                chunk_result['status'] = 'summarized'
+            except Exception as e:
+                summaries.append(f"**Chunk {i+1}**: ❌ Error: {str(e)}")
+                chunk_result['status'] = 'error'
 
-    for summary, info in results:
-        summaries.append(summary)
-        chunk_info.append(info)
+        chunk_result['time'] = time.time() - chunk_start
+        chunk_info.append(chunk_result)
 
-    final_summary = f"**Chunks**: {len(chunks)}\n**Time**: {time.time() - start:.2f}s\n\n" + "\n\n".join(summaries)
-    process_img = visualize_chunk_status(chunk_info)
-    flow_img = create_summary_flowchart(summaries)
-    return final_summary, process_img, flow_img
+    final_summary = f"**Chars**: {len(text)}\n**Time**: {time.time()-start:.2f}s\n\n" + "\n\n".join(summaries)
+    image = visualize_chunk_status(chunk_info)
+    return final_summary, image
 
 demo = gr.Interface(
     fn=summarize_file,
-    inputs=gr.File(label="Upload PDF", type="binary"),
+    inputs=gr.File(label="📄 Upload PDF", type="binary"),
     outputs=[
-        gr.Textbox(label="Summary", lines=15),
-        gr.Image(label="Chunk Status", type="pil"),
-        gr.Image(label="Key Points Flowchart", type="pil")
+        gr.Textbox(label="📝 Summarized Output"),
+        gr.Image(label="📊 Visual Process Flow", type="pil")
     ],
-    title="PDF Summarizer",
-    description="Summarizes PDFs up to 30,000 characters with key point flowchart."
+    title="AI-Powered PDF Summarizer",
+    description="Summarizes long PDFs (up to 300,000 characters) and visualizes chunk-level automation status."
 )
 
 if __name__ == "__main__":
     try:
-        logger.info("Starting Gradio on http://127.0.0.1:7860")
-        demo.launch(
-            share=False,
-            server_name="127.0.0.1",
-            server_port=7860,
-            debug=False
-        )
+        demo.launch(share=False, server_port=7860)
     except Exception as e:
-        logger.error(f"Failed on port 7860: {str(e)}")
-        logger.info("Trying port 7861...")
-        try:
-            demo.launch(
-                share=False,
-                server_name="127.0.0.1",
-                server_port=7861,
-                debug=False
-            )
-        except Exception as e2:
-            logger.error(f"Failed on port 7861: {str(e2)}")
-            raise
+        print(f"❌ Gradio launch failed: {str(e)}")