Create app.py

app.py

@@ -0,0 +1,143 @@
+import gradio as gr
+import os
+import re
+import PyPDF2
+import numpy as np
+from sentence_transformers import SentenceTransformer
+from sklearn.metrics.pairwise import cosine_similarity
+
+# ----------------------------
+# PDF Processing Engine
+# ----------------------------
+
+class PDFAnalyzer:
+    def __init__(self):
+        self.text_chunks = []
+        self.embeddings = None
+        self.active_doc = None
+        self.model = SentenceTransformer('all-MiniLM-L6-v2')
+        
+    def process_pdf(self, filepath):
+        """Handle PDF file processing pipeline"""
+        try:
+            if not filepath.lower().endswith('.pdf'):
+                return False, "Invalid file format - PDF required"
+                
+            text = self._extract_text(filepath)
+            self.text_chunks = self._chunk_text(text)
+            self.embeddings = self.model.encode(self.text_chunks)
+            self.active_doc = os.path.basename(filepath)
+            return True, f"Loaded {self.active_doc} ({len(self.text_chunks)} chunks)"
+            
+        except PyPDF2.errors.PdfReadError:
+            return False, "Error reading PDF - file may be corrupted"
+        except Exception as e:
+            return False, f"Processing error: {str(e)}"
+    
+    def _extract_text(self, filepath):
+        """Extract text from PDF document"""
+        text = ""
+        with open(filepath, 'rb') as f:
+            reader = PyPDF2.PdfReader(f)
+            for page in reader.pages:
+                text += page.extract_text() or ""
+        return text
+    
+    def _chunk_text(self, text, chunk_size=400):
+        """Create semantic chunks from document text"""
+        sentences = re.split(r'(?<!\w\.\w.)(?<![A-Z][a-z]\.)(?<=\.|\?)\s', text)
+        chunks = []
+        current_chunk = []
+        count = 0
+        
+        for sentence in sentences:
+            current_chunk.append(sentence)
+            count += len(sentence.split())
+            if count >= chunk_size:
+                chunks.append(' '.join(current_chunk))
+                current_chunk = []
+                count = 0
+                
+        if current_chunk:
+            chunks.append(' '.join(current_chunk))
+        return chunks
+    
+    def query_document(self, question):
+        """Find relevant document section for a question"""
+        if not self.active_doc:
+            return "No active document. Please upload a PDF first."
+            
+        question_embed = self.model.encode(question)
+        similarities = cosine_similarity([question_embed], self.embeddings)[0]
+        best_match = np.argmax(similarities)
+        return self.text_chunks[best_match]
+
+# ----------------------------
+# Gradio Interface
+# ----------------------------
+
+def create_interface():
+    analyzer = PDFAnalyzer()
+    chat_history = []
+    
+    def process_file(file):
+        success, message = analyzer.process_pdf(file.name)
+        status = f"✅ {message}" if success else f"❌ {message}"
+        return status
+    
+    def respond(message, history):
+        nonlocal analyzer
+        
+        # Handle document queries
+        if analyzer.active_doc:
+            response = analyzer.query_document(message)
+            history.append((message, response))
+            return history, history
+        
+        # Handle initial state
+        history.append((message, "Please upload a PDF document first"))
+        return history, history
+    
+    def clear_chat():
+        nonlocal analyzer
+        analyzer = PDFAnalyzer()
+        return [], [], "❌ No document loaded"
+
+    with gr.Blocks(title="PDF Analysis Assistant", theme=gr.themes.Soft()) as app:
+        gr.Markdown("# 📄 PDF Analysis Assistant")
+        gr.Markdown("Upload a PDF document and ask questions about its content")
+        
+        with gr.Row():
+            with gr.Column(scale=1):
+                file_input = gr.File(label="Upload PDF", type="filepath")
+                status_output = gr.Markdown("❌ No document loaded")
+                upload_btn = gr.Button("Process Document")
+            
+            with gr.Column(scale=2):
+                chatbot = gr.Chatbot(label="Conversation")
+                msg = gr.Textbox(label="Your Question")
+                clear_btn = gr.Button("Clear Chat")
+        
+        # Event handling
+        upload_btn.click(
+            process_file,
+            inputs=file_input,
+            outputs=status_output
+        )
+        
+        msg.submit(
+            respond,
+            inputs=[msg, chatbot],
+            outputs=[chatbot, chatbot]
+        )
+        
+        clear_btn.click(
+            clear_chat,
+            outputs=[chatbot, file_input, status_output]
+        )
+
+    return app
+
+if __name__ == "__main__":
+    app = create_interface()
+    app.launch()