Update app.py

app.py

@@ -1,5 +1,3 @@
-# Install dependencies
-
 import gradio as gr
 import fitz
 import numpy as np
@@ -12,9 +10,10 @@ from docx import Document
 from pptx import Presentation
 from sentence_transformers import SentenceTransformer
 from concurrent.futures import ThreadPoolExecutor
+import os
 
-# Configuration
-GEMINI_API_KEY = "AIzaSyAPF8eVHU2jRWrQfwD8J9HPz4DrfIWK4GQ"  # 🔑 REPLACE WITH YOUR GEMINI KEY
+# Configuration - Get API key from Hugging Face secrets
+GEMINI_API_KEY = os.environ.get("AIzaSyAPF8eVHU2jRWrQfwD8J9HPz4DrfIWK4GQ")
 MODEL_NAME = "all-MiniLM-L6-v2"
 CHUNK_SIZE = 1024
 MAX_TOKENS = 4096
@@ -27,7 +26,97 @@ class DocumentProcessor:
         self.chunks = []
         self.processor_pool = ThreadPoolExecutor(max_workers=WORKERS)
 
-    # ... (keep all existing document processing methods unchanged) ...
+    # File processing methods remain unchanged from original
+    def extract_text_from_pptx(self, file_path):
+        try:
+            prs = Presentation(file_path)
+            return " ".join([shape.text for slide in prs.slides for shape in slide.shapes if hasattr(shape, "text")])
+        except Exception as e:
+            print(f"PPTX Error: {str(e)}")
+            return ""
+
+    def extract_text_from_xls_csv(self, file_path):
+        try:
+            if file_path.endswith(('.xls', '.xlsx')):
+                df = pd.read_excel(file_path)
+            else:
+                df = pd.read_csv(file_path)
+            return " ".join(df.astype(str).values.flatten())
+        except Exception as e:
+            print(f"Spreadsheet Error: {str(e)}")
+            return ""
+
+    def extract_text_from_pdf(self, file_path):
+        try:
+            doc = fitz.open(file_path)
+            return " ".join(page.get_text("text", flags=fitz.TEXT_PRESERVE_WHITESPACE) for page in doc)
+        except Exception as e:
+            print(f"PDF Error: {str(e)}")
+            return ""
+
+    def process_file(self, file):
+        try:
+            file_path = file.name
+            print(f"Processing: {file_path}")
+
+            if file_path.endswith('.pdf'):
+                text = self.extract_text_from_pdf(file_path)
+            elif file_path.endswith('.docx'):
+                text = " ".join(p.text for p in Document(file_path).paragraphs)
+            elif file_path.endswith('.txt'):
+                with open(file_path, 'r', encoding='utf-8') as f:
+                    text = f.read()
+            elif file_path.endswith('.pptx'):
+                text = self.extract_text_from_pptx(file_path)
+            elif file_path.endswith(('.xls', '.xlsx', '.csv')):
+                text = self.extract_text_from_xls_csv(file_path)
+            else:
+                return ""
+
+            clean_text = re.sub(r'\s+', ' ', text).strip()
+            print(f"Extracted {len(clean_text)} characters from {file_path}")
+            return clean_text
+        except Exception as e:
+            print(f"Processing Error: {str(e)}")
+            return ""
+
+    def semantic_chunking(self, text):
+        words = re.findall(r'\S+\s*', text)
+        chunks = [''.join(words[i:i+CHUNK_SIZE//2]) for i in range(0, len(words), CHUNK_SIZE//2)]
+        return chunks[:1000]
+
+    def process_documents(self, files):
+        self.chunks = []
+        if not files:
+            return "No files uploaded!"
+
+        print("\n" + "="*40 + " PROCESSING DOCUMENTS " + "="*40)
+        texts = list(self.processor_pool.map(self.process_file, files))
+
+        with ThreadPoolExecutor(max_workers=WORKERS) as executor:
+            chunk_lists = list(executor.map(self.semantic_chunking, texts))
+
+        all_chunks = [chunk for chunk_list in chunk_lists for chunk in chunk_list]
+        print(f"Total chunks generated: {len(all_chunks)}")
+
+        if not all_chunks:
+            return "Error: No chunks generated from documents"
+
+        try:
+            embeddings = MODEL.encode(
+                all_chunks,
+                batch_size=256,
+                convert_to_tensor=True,
+                show_progress_bar=False
+            ).cpu().numpy().astype('float32')
+
+            self.index.reset()
+            self.index.add(embeddings)
+            self.chunks = all_chunks
+            return f"Processed {len(all_chunks)} chunks from {len(files)} files"
+        except Exception as e:
+            print(f"Embedding Error: {str(e)}")
+            return f"Error: {str(e)}"
 
     def query(self, question):
         if not self.chunks:
@@ -71,26 +160,75 @@ class DocumentProcessor:
                 timeout=20
             )
 
-            print(f"API Status Code: {response.status_code}")
-
             if response.status_code != 200:
                 return f"API Error: {response.text}", False
 
-            # Parse Gemini response
-            response_json = response.json()
+            # Parse response
             try:
+                response_json = response.json()
                 final_answer = response_json['candidates'][0]['content']['parts'][0]['text']
             except (KeyError, IndexError) as e:
                 print(f"Response parsing error: {str(e)}")
                 return "Error: Could not parse API response", False
 
-            print(f"Final Answer: {final_answer}")
             return final_answer, True
 
         except Exception as e:
             print(f"Query Error: {str(e)}")
             return f"Error: {str(e)}", False
 
+# Initialize processor
+processor = DocumentProcessor()
+
+# Gradio interface with improved error handling
+with gr.Blocks(theme=gr.themes.Soft(), title="Chatbot") as app:
+    gr.Markdown("## 📚 Multi-Format Document Chatbot")
+    
+    with gr.Row():
+        with gr.Column(scale=2):
+            files = gr.File(
+                file_count="multiple",
+                file_types=[".pdf", ".docx", ".txt", ".pptx", ".xls", ".xlsx", ".csv"],
+                label="Upload Documents",
+                max_size=500*1024*1024  # 500MB limit
+            )
+            process_btn = gr.Button("Process Documents", variant="primary")
+            status = gr.Textbox(label="Processing Status")
+            
+        with gr.Column(scale=3):
+            chatbot = gr.Chatbot(height=500, label="Chat History")
+            question = gr.Textbox(
+                label="Ask a question",
+                placeholder="Type your question here...",
+                max_lines=3
+            )
+            with gr.Row():
+                ask_btn = gr.Button("Ask", variant="primary")
+                clear_btn = gr.Button("Clear Chat")
+
+    process_btn.click(
+        fn=processor.process_documents,
+        inputs=files,
+        outputs=status,
+        api_name="process_documents"
+    )
+
+    ask_btn.click(
+        fn=lambda q, h: ask_question(q, h),
+        inputs=[question, chatbot],
+        outputs=chatbot,
+        api_name="ask_question"
+    ).then(lambda: "", None, question)
+
+    clear_btn.click(
+        fn=lambda: [],
+        inputs=None,
+        outputs=chatbot,
+        api_name="clear_chat"
+    )
+
+if __name__ == "__main__":
+    app.launch(debug=True)
 # ... (keep the rest of the Gradio interface code unchanged) ...
 
 '''