Create app.py

app.py

@@ -0,0 +1,615 @@
+import os
+import re
+import tempfile
+import gradio as gr
+from transformers import pipeline
+import pdfplumber
+from gtts import gTTS
+import nltk
+import numpy as np
+from sklearn.feature_extraction.text import TfidfVectorizer
+from pydub import AudioSegment
+import faiss
+from sentence_transformers import SentenceTransformer
+from groq import Groq
+from diffusers import StableDiffusionPipeline
+import torch
+from PIL import Image
+
+# ==========================================================
+# 🧠 NLTK Setup
+# ==========================================================
+for pkg in ["punkt", "punkt_tab"]:
+    try:
+        nltk.data.find(f"tokenizers/{pkg}")
+    except LookupError:
+        nltk.download(pkg)
+
+# ==========================================================
+# 🔐 Environment Setup
+# ==========================================================
+GROQ_API_KEY = os.getenv("GROQ_API_KEY", "")
+
+# ==========================================================
+# ⚙️ Model Setup
+# ==========================================================
+DEVICE = "cuda" if torch.cuda.is_available() else "cpu"
+print(f"Using device: {DEVICE}")
+
+# Initialize models
+print("Loading models... please wait ⏳")
+
+# Summarization model
+SUMMARIZER_MODEL = "facebook/bart-large-cnn"
+try:
+    summarizer = pipeline("summarization", model=SUMMARIZER_MODEL)
+    print("✅ Summarizer loaded successfully.")
+except Exception as e:
+    print("❌ Summarizer load error:", e)
+    summarizer = None
+
+# Embedding model for RAG
+try:
+    embedder = SentenceTransformer('all-MiniLM-L6-v2')
+    print("✅ Embedding model loaded successfully.")
+except Exception as e:
+    print("❌ Embedding model load error:", e)
+    embedder = None
+
+# Stable Diffusion for diagram generation
+try:
+    if torch.cuda.is_available():
+        sd_pipe = StableDiffusionPipeline.from_pretrained(
+            "runwayml/stable-diffusion-v1-5",
+            torch_dtype=torch.float16,
+            safety_checker=None,
+            requires_safety_checker=False
+        )
+        sd_pipe = sd_pipe.to("cuda")
+    else:
+        sd_pipe = StableDiffusionPipeline.from_pretrained("runwayml/stable-diffusion-v1-5")
+        sd_pipe = sd_pipe.to("cpu")
+    print("✅ Stable Diffusion loaded successfully.")
+except Exception as e:
+    print("❌ Stable Diffusion load error:", e)
+    sd_pipe = None
+
+# Groq client
+try:
+    groq_client = Groq(api_key=GROQ_API_KEY) if GROQ_API_KEY else None
+    if groq_client:
+        print("✅ Groq client initialized successfully.")
+    else:
+        print("⚠️ Groq API key not found. Chat functionality will be limited.")
+except Exception as e:
+    print("❌ Groq client initialization error:", e)
+    groq_client = None
+
+# ==========================================================
+# 🧩 Utility Functions
+# ==========================================================
+def clean_text(text: str) -> str:
+    """Clean extracted PDF text."""
+    text = re.sub(r'\r\n?', '\n', text)
+    text = re.sub(r'\n{2,}', '\n\n', text)
+    text = re.sub(r'References[\s\S]*', '', text, flags=re.IGNORECASE)
+    text = re.sub(r'[^\x00-\x7F]+', ' ', text)
+    text = re.sub(r'\s+', ' ', text)
+    return text.strip()
+
+def extract_text_from_pdf(path: str) -> str:
+    """Extract text from all pages of a PDF."""
+    try:
+        text = ""
+        with pdfplumber.open(path) as pdf:
+            for page in pdf.pages:
+                page_text = page.extract_text()
+                if page_text:
+                    text += page_text + "\n\n"
+        return text.strip() if text.strip() else "No text extracted from PDF."
+    except Exception as e:
+        return f"Error extracting text: {e}"
+
+def sentence_tokenize(text: str):
+    """Split text into sentences."""
+    return [s.strip() for s in nltk.tokenize.sent_tokenize(text) if len(s.strip()) > 10]
+
+def chunk_text(text: str, max_chars=1500):
+    """Split text into chunks for summarization."""
+    sents = sentence_tokenize(text)
+    chunks, cur = [], ""
+    for s in sents:
+        if len(cur) + len(s) < max_chars:
+            cur += (" " if cur else "") + s
+        else:
+            chunks.append(cur)
+            cur = s
+    if cur:
+        chunks.append(cur)
+    return chunks
+
+def extract_keywords_tfidf(text: str, top_k=8):
+    """Extract keywords using TF-IDF."""
+    try:
+        paras = [p.strip() for p in re.split(r'\n{2,}', text) if len(p.strip()) > 0]
+        vectorizer = TfidfVectorizer(stop_words='english', ngram_range=(1, 2))
+        X = vectorizer.fit_transform(paras)
+        features = vectorizer.get_feature_names_out()
+        scores = np.asarray(X.mean(axis=0)).ravel()
+        idx = np.argsort(scores)[::-1][:top_k]
+        return [features[i] for i in idx]
+    except Exception:
+        return []
+
+# ==========================================================
+# ✍️ Adaptive Summarization
+# ==========================================================
+def summarize_long_text(text: str) -> str:
+    """Adaptive summarization based on PDF length."""
+    if summarizer is None:
+        return "Summarization model unavailable."
+
+    text = clean_text(text)
+    L = len(text)
+
+    # Dynamic summarization scaling
+    if L < 1500:
+        max_len, min_len, chunk_size = 180, 60, 1400
+    elif L < 5000:
+        max_len, min_len, chunk_size = 250, 100, 1600
+    elif L < 15000:
+        max_len, min_len, chunk_size = 350, 150, 1800
+    else:
+        max_len, min_len, chunk_size = 500, 200, 2000
+
+    if L <= chunk_size:
+        return summarizer(text, max_length=max_len, min_length=min_len, do_sample=False)[0]["summary_text"]
+
+    parts = chunk_text(text, max_chars=chunk_size)[:6]
+    summaries = []
+    for p in parts:
+        try:
+            summaries.append(summarizer(p, max_length=200, min_length=80, do_sample=False)[0]["summary_text"])
+        except Exception:
+            continue
+
+    combined = " ".join(summaries)
+    final = summarizer(combined, max_length=max_len, min_length=min_len, do_sample=False)[0]["summary_text"]
+    return final
+
+# ==========================================================
+# 🖼️ Diagram Generation with Stable Diffusion
+# ==========================================================
+def generate_diagram(summary: str, keywords: str) -> Image.Image:
+    """Generate a diagram based on summary and keywords."""
+    if sd_pipe is None:
+        return None
+
+    try:
+        # Create a prompt for diagram generation
+        prompt = f"educational diagram, infographic style, clean and professional, illustrating: {summary[:500]}. Keywords: {keywords}"
+
+        # Generate image
+        with torch.no_grad():
+            if torch.cuda.is_available():
+                image = sd_pipe(
+                    prompt,
+                    num_inference_steps=25,
+                    guidance_scale=7.5,
+                    width=512,
+                    height=512
+                ).images[0]
+            else:
+                image = sd_pipe(
+                    prompt,
+                    num_inference_steps=15,
+                    guidance_scale=7.5,
+                    width=512,
+                    height=512
+                ).images[0]
+
+        return image
+    except Exception as e:
+        print(f"Diagram generation error: {e}")
+        return None
+
+# ==========================================================
+# 💬 RAG Chatbot Functions
+# ==========================================================
+class PDFChatBot:
+    def __init__(self):
+        self.vector_store = None
+        self.chunks = []
+        self.current_pdf_text = ""
+        self.is_processed = False
+
+    def process_pdf_for_chat(self, pdf_text: str):
+        """Process PDF text for RAG system."""
+        if not pdf_text or pdf_text.startswith("Error") or pdf_text.startswith("No text"):
+            return False
+
+        self.current_pdf_text = clean_text(pdf_text)
+
+        # Chunk the text
+        self.chunks = self._create_chunks(self.current_pdf_text, chunk_size=500, overlap=50)
+
+        # Create embeddings
+        if embedder is not None and self.chunks:
+            embeddings = embedder.encode(self.chunks)
+
+            # Create FAISS index
+            dimension = embeddings.shape[1]
+            self.vector_store = faiss.IndexFlatIP(dimension)
+
+            # Normalize embeddings for cosine similarity
+            faiss.normalize_L2(embeddings)
+            self.vector_store.add(embeddings)
+
+            self.is_processed = True
+            return True
+        return False
+
+    def _create_chunks(self, text: str, chunk_size: int = 500, overlap: int = 50):
+        """Create overlapping chunks of text."""
+        sentences = sentence_tokenize(text)
+        chunks = []
+        current_chunk = ""
+
+        for sentence in sentences:
+            if len(current_chunk) + len(sentence) <= chunk_size:
+                current_chunk += " " + sentence
+            else:
+                if current_chunk:
+                    chunks.append(current_chunk.strip())
+                current_chunk = sentence
+
+        if current_chunk:
+            chunks.append(current_chunk.strip())
+
+        return chunks
+
+    def get_relevant_chunks(self, query: str, top_k: int = 3):
+        """Retrieve relevant chunks for a query."""
+        if self.vector_store is None or not self.chunks:
+            return []
+
+        try:
+            # Encode query
+            query_embedding = embedder.encode([query])
+            faiss.normalize_L2(query_embedding)
+
+            # Search
+            scores, indices = self.vector_store.search(query_embedding, top_k)
+
+            # Return relevant chunks
+            relevant_chunks = []
+            for i, score in zip(indices[0], scores[0]):
+                if i < len(self.chunks) and score > 0.3:  # similarity threshold
+                    relevant_chunks.append(self.chunks[i])
+
+            return relevant_chunks
+        except Exception as e:
+            print(f"Error in retrieval: {e}")
+            return []
+
+    def generate_answer(self, query: str, chat_history):
+        """Generate answer using RAG with Groq."""
+        if groq_client is None:
+            return "Groq API not available. Please set your GROQ_API_KEY in the Hugging Face Spaces secrets."
+
+        if not self.is_processed:
+            return "Please upload and process a PDF first. Go to the 'PDF Summarizer' tab to upload your PDF."
+
+        # Get relevant context
+        relevant_chunks = self.get_relevant_chunks(query)
+
+        if not relevant_chunks:
+            return "No relevant information found in the PDF for your question."
+
+        context = "\n\n".join(relevant_chunks[:3])  # Use top 3 chunks
+
+        # Create prompt
+        prompt = f"""Based on the following context from a PDF document, please answer the user's question.
+
+Context:
+{context}
+
+Question: {query}
+
+Please provide a helpful and accurate answer based only on the given context. If the context doesn't contain enough information to fully answer the question, please say so."""
+
+        try:
+            # Try different available Groq models
+            available_models = [
+                "llama-3.3-70b-versatile",
+                "llama-3.1-8b-instant",
+                "llama-3.2-3b-preview",
+                "llama-3.2-1b-preview",
+                "mixtral-8x7b-32768"
+            ]
+
+            for model in available_models:
+                try:
+                    completion = groq_client.chat.completions.create(
+                        model=model,
+                        messages=[{"role": "user", "content": prompt}],
+                        temperature=0.7,
+                        max_tokens=1024,
+                        top_p=1,
+                        stream=False
+                    )
+
+                    answer = completion.choices[0].message.content
+                    return answer
+
+                except Exception as model_error:
+                    print(f"Model {model} failed: {model_error}")
+                    continue
+
+            return "All available models failed. Please check your Groq API access."
+
+        except Exception as e:
+            return f"Error generating answer: {str(e)}"
+
+# Initialize chatbot
+chatbot = PDFChatBot()
+
+# ==========================================================
+# 🔊 Text-to-Speech
+# ==========================================================
+def text_to_speech(text):
+    """Convert text to speech and ensure WAV output."""
+    if not text:
+        return None
+    try:
+        # Temporary paths
+        mp3_path = tempfile.NamedTemporaryFile(delete=False, suffix=".mp3").name
+        wav_path = tempfile.NamedTemporaryFile(delete=False, suffix=".wav").name
+
+        # Generate TTS (MP3)
+        gTTS(text=text[:900], lang="en").save(mp3_path)
+
+        # Convert to WAV for browser playback
+        AudioSegment.from_mp3(mp3_path).export(wav_path, format="wav")
+
+        # Clean up MP3 file
+        os.unlink(mp3_path)
+
+        return wav_path
+    except Exception as e:
+        print("TTS error:", e)
+        return None
+
+# ==========================================================
+# 📄 PDF Processing - Main Function
+# ==========================================================
+def process_pdf(pdf_file):
+    """Main handler to process PDF - this will be shared across all tabs."""
+    if not pdf_file:
+        return "Please upload a PDF.", "", None, "", None, "No PDF uploaded"
+
+    text = extract_text_from_pdf(pdf_file)
+    if text.startswith("Error") or text.startswith("No text"):
+        return text, "", None, "", None, "Failed to extract text"
+
+    text = clean_text(text)
+    summary = summarize_long_text(text)
+    keywords = ", ".join(extract_keywords_tfidf(text))
+    audio = text_to_speech(summary)
+
+    # Generate diagram
+    diagram = generate_diagram(summary, keywords)
+
+    # Also process for chatbot
+    chatbot.process_pdf_for_chat(text)
+
+    # Return status message for chat tab
+    status_message = "✅ PDF processed successfully! You can now chat with this PDF in the 'Chat with PDF' tab."
+
+    return text, summary, audio, keywords, diagram, status_message
+
+# ==========================================================
+# 🚀 Gradio Interface with Shared PDF State
+# ==========================================================
+def create_interface():
+    with gr.Blocks(
+        title="AI PDF Summarizer Pro",
+        theme=gr.themes.Soft()
+    ) as demo:
+
+        gr.Markdown("""
+        # AI PDF Summarizer Pro
+        *Upload once, use everywhere across all tabs*
+        """)
+
+        # --- Main Tab: PDF Summarizer ---
+        with gr.Tab("📄 PDF Summarizer"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Upload Your PDF")
+                    gr.Markdown("Upload a PDF here and it will be automatically available in all other tabs.")
+                    pdf_input = gr.File(
+                        label="Upload PDF Document",
+                        file_types=[".pdf"],
+                        type="filepath"
+                    )
+                    process_btn = gr.Button(
+                        "Process PDF",
+                        variant="primary",
+                        size="lg"
+                    )
+
+                with gr.Column(scale=2):
+                    with gr.Accordion("Extracted Text", open=False):
+                        extracted_text = gr.Textbox(
+                            label="",
+                            lines=8,
+                            interactive=False,
+                            show_copy_button=True
+                        )
+
+                    with gr.Row():
+                        with gr.Column():
+                            summary_box = gr.Textbox(
+                                label="AI Summary",
+                                lines=4,
+                                interactive=False,
+                                show_copy_button=True
+                            )
+                        with gr.Column():
+                            keywords_box = gr.Textbox(
+                                label="Top Keywords",
+                                lines=2,
+                                interactive=False
+                            )
+
+                    with gr.Row():
+                        with gr.Column():
+                            audio_box = gr.Audio(
+                                label="Summary Audio",
+                                type="filepath",
+                                interactive=False
+                            )
+                        with gr.Column():
+                            diagram_box = gr.Image(
+                                label="AI Generated Diagram",
+                                interactive=False,
+                                height=200
+                            )
+
+                    # Status message
+                    status_display = gr.HTML(
+                        value="<div>No PDF processed yet. Upload a PDF and click 'Process PDF'.</div>"
+                    )
+
+        # --- Tab: AI Diagram Generator ---
+        with gr.Tab("🖼️ AI Diagram"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("### Create Diagram")
+                    gr.Markdown("Create diagrams using the summary from your uploaded PDF or enter custom text.")
+                    diagram_summary_input = gr.Textbox(
+                        label="Summary Text",
+                        lines=3,
+                        placeholder="Text from your PDF summary will appear here after processing..."
+                    )
+                    diagram_keywords_input = gr.Textbox(
+                        label="Keywords (optional)",
+                        placeholder="Keywords from your PDF will appear here..."
+                    )
+                    generate_diagram_btn = gr.Button(
+                        "Generate Diagram",
+                        variant="primary"
+                    )
+
+                with gr.Column():
+                    gr.Markdown("### Generated Diagram")
+                    diagram_output = gr.Image(
+                        label="",
+                        interactive=False,
+                        height=400,
+                        show_download_button=True
+                    )
+
+        # --- Tab: Chat with PDF ---
+        with gr.Tab("💬 Chat with PDF"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("### Chat with Your PDF")
+                    gr.Markdown("""
+                    **Ask questions about your uploaded PDF**
+
+                    Simply go to the **PDF Summarizer** tab, upload and process your PDF, then come back here to start chatting!
+                    """)
+
+                    # Display current PDF status
+                    chat_status_display = gr.HTML(
+                        value="<div>Please upload and process a PDF in the 'PDF Summarizer' tab first.</div>"
+                    )
+
+                with gr.Column(scale=2):
+                    chatbot_interface = gr.ChatInterface(
+                        fn=chatbot.generate_answer,
+                        title="Chat with Your PDF",
+                        description="Ask questions about the content of your uploaded PDF document",
+                        examples=[
+                            "What is the main topic of this document?",
+                            "Can you summarize the key points?",
+                            "What are the most important findings?",
+                            "Explain the methodology used",
+                            "What conclusions does the author reach?"
+                        ]
+                    )
+
+        # --- Tab: About ---
+        with gr.Tab("ℹ️ About"):
+            gr.Markdown("""
+            ## About AI PDF Summarizer Pro
+
+            **One PDF Upload, Multiple AI Features**
+
+            Upload your PDF once in the **PDF Summarizer** tab and use it across all features:
+
+            - **📄 PDF Summarizer**: Extract text, generate summaries, get keywords
+            - **🖼️ AI Diagram**: Create visual diagrams from your content
+            - **💬 Chat with PDF**: Ask questions and get instant answers
+
+            ### How it works:
+            1. Upload your PDF in the **PDF Summarizer** tab
+            2. Click **Process PDF**
+            3. The same PDF is automatically available in all other tabs
+            4. No need to re-upload - seamless experience!
+
+            ### Powered by:
+            - Hugging Face Transformers
+            - Stable Diffusion
+            - Groq API
+            - FAISS Vector Search
+
+            ### Setup Instructions:
+            For full functionality, add your Groq API key in Hugging Face Spaces secrets:
+            - Go to your Space settings
+            - Add a secret named `GROQ_API_KEY` with your Groq API key
+            """)
+
+        # --- Event Handlers ---
+
+        # Main PDF processing - updates all tabs
+        process_btn.click(
+            process_pdf,
+            inputs=[pdf_input],
+            outputs=[extracted_text, summary_box, audio_box, keywords_box, diagram_box, status_display]
+        ).then(
+            # Update the diagram tab inputs with the generated summary and keywords
+            lambda summary, keywords: (summary, keywords),
+            inputs=[summary_box, keywords_box],
+            outputs=[diagram_summary_input, diagram_keywords_input]
+        ).then(
+            # Update chat status
+            lambda: "<div>✅ PDF processed successfully! You can now chat with your document.</div>",
+            outputs=[chat_status_display]
+        )
+
+        # Standalone diagram generation
+        generate_diagram_btn.click(
+            generate_diagram,
+            inputs=[diagram_summary_input, diagram_keywords_input],
+            outputs=[diagram_output]
+        )
+
+    return demo
+
+# ==========================================================
+# 🚀 Launch Application
+# ==========================================================
+if __name__ == "__main__":
+    print("Starting AI PDF Summarizer Pro...")
+    print("Key Feature: Upload PDF once, use across all tabs!")
+    print("Loading AI models...")
+    print("✅ Summarization Model")
+    print("✅ Embedding Model")
+    print("✅ Diagram Generation")
+    print("✅ Chat Model")
+
+    demo = create_interface()
+    demo.launch(share=False)