Update app.py

app.py

@@ -1,59 +1,182 @@
-import streamlit as st
-from google import genai
 import os
+import base64
+import streamlit as st
+from docx import Document
+import openpyxl
+from pdfminer.high_level import extract_text
+import csv
+from pptx import Presentation
+from io import StringIO
+from bs4 import BeautifulSoup
+import re
+import google.generativeai as genai
 
-# Access the API key from environment variables
-api_key = os.getenv("GOOGLE_API_KEY")
+# Setup
+st.set_page_config(page_title="Gemini Q&A App", layout="centered")
+st.title("🤖 Q&A - Document & Image with Web Search")
+
+# Initialize chat history
+if "chat_history" not in st.session_state:
+    st.session_state.chat_history = []
 
-# Check if the API key is present
-if not api_key:
-    raise EnvironmentError("GOOGLE_API_KEY not set in environment variables.")
+# Optional: Clear history button
+if st.button("🧹 Clear Chat History"):
+    st.session_state.chat_history = []
 
-# Set the environment variable for the Google API client
-os.environ["GOOGLE_API_KEY"] = api_key
+# Load API key
+GOOGLE_API_KEY = os.environ.get("GOOGLE_API_KEY") or st.secrets.get("GOOGLE_API_KEY")
+if not GOOGLE_API_KEY:
+    st.error("GOOGLE_API_KEY not found in environment or Streamlit secrets.")
+    st.stop()
 
-# Initialize the client
+genai.configure(api_key=GOOGLE_API_KEY)
 client = genai.Client()
 MODEL_ID = "gemini-2.0-flash"
 
-# Function to chat with Gemini
-def chat_with_gemini(message, history):
+# Helper: Extract text from various documents
+def load_and_extract_text(file_path):
     try:
-        response = client.models.generate_content(
-            model=MODEL_ID,
-            contents=message,
-            config={"tools": [{"google_search": {}}]},
-        )
-        return response.text
+        ext = file_path.split('.')[-1].lower()
+
+        if ext == 'docx':
+            doc = Document(file_path)
+            return '\n'.join(p.text for p in doc.paragraphs)
+
+        elif ext == 'xlsx':
+            workbook = openpyxl.load_workbook(file_path)
+            return '\n'.join(
+                ' '.join(str(cell.value) for cell in row if cell.value is not None)
+                for sheet in workbook for row in sheet.iter_rows()
+            )
+
+        elif ext == 'pdf':
+            return extract_text(file_path)
+
+        elif ext == 'csv':
+            with open(file_path, 'r', encoding='utf-8') as f:
+                reader = csv.reader(f)
+                return '\n'.join(' '.join(row) for row in reader)
+
+        elif ext == 'txt':
+            with open(file_path, 'r', encoding='utf-8') as f:
+                return f.read()
+
+        elif ext == 'pptx':
+            prs = Presentation(file_path)
+            return '\n'.join(
+                shape.text for slide in prs.slides for shape in slide.shapes if hasattr(shape, 'text')
+            )
+
+        elif ext == 'tex':
+            with open(file_path, 'r', encoding='utf-8') as f:
+                content = f.read()
+                content = re.sub(r'\\[a-zA-Z]+\*?(?:\[[^\]]*\])?(?:\{[^}]*\})*', '', content)
+                content = re.sub(r'%.*', '', content)
+                return content.strip()
+
+        elif ext in ['html', 'htm']:
+            with open(file_path, 'r', encoding='utf-8') as f:
+                soup = BeautifulSoup(f, 'html.parser')
+                for script_or_style in soup(['script', 'style']):
+                    script_or_style.decompose()
+                return soup.get_text(separator='\n', strip=True)
+
+        else:
+            return "Unsupported file format."
+
     except Exception as e:
-        return f"Error: {str(e)}"
+        return f"Error processing file: {e}"
 
-# Streamlit app
-st.title("Gemini Chatbot (with Google Search)")
-st.write("Ask anything and get responses powered by Gemini 2.0 Flash.")
+# Multi-file uploader
+uploaded_files = st.file_uploader(
+    "Upload one or more documents or images",
+    type=["docx", "xlsx", "pdf", "csv", "txt", "pptx", "tex", "html", "htm", "jpg", "jpeg", "png"],
+    accept_multiple_files=True
+)
 
-# Initialize chat history
-if 'history' not in st.session_state:
-    st.session_state['history'] = []
-
-# Input field for the user to type their message
-user_input = st.text_input("You:", "")
-
-# Button to send the message
-if st.button("Send"):
-    if user_input:
-        # Add user message to history
-        st.session_state.history.append({"role": "user", "message": user_input})
-        
-        # Get response from Gemini
-        gemini_response = chat_with_gemini(user_input, st.session_state.history)
-        
-        # Add Gemini response to history
-        st.session_state.history.append({"role": "assistant", "message": gemini_response})
-        
-        # Display the chat history
-        for chat in st.session_state.history:
-            if chat["role"] == "user":
-                st.chat_message("user").markdown(chat["message"])
-            else:
-                st.chat_message("assistant").markdown(chat["message"])
+# Question input
+question = st.text_input("💬 Enter your question:")
+
+# Processing
+if uploaded_files and question:
+    combined_context = ""
+    image_contents = []
+
+    for uploaded_file in uploaded_files:
+        file_ext = uploaded_file.name.split('.')[-1].lower()
+
+        if file_ext in ['jpg', 'jpeg', 'png']:
+            image_bytes = uploaded_file.read()
+            encoded_image = base64.b64encode(image_bytes).decode("utf-8")
+            image_contents.append({
+                "inline_data": {
+                    "mime_type": uploaded_file.type,
+                    "data": encoded_image
+                }
+            })
+            st.image(image_bytes, caption=uploaded_file.name, use_container_width=True)
+            continue
+
+        temp_file_path = "temp." + file_ext
+        with open(temp_file_path, "wb") as temp_file:
+            temp_file.write(uploaded_file.read())
+
+        extracted_text = load_and_extract_text(temp_file_path)
+        os.remove(temp_file_path)
+
+        if "Error" in extracted_text or "Unsupported" in extracted_text:
+            st.error(f"{uploaded_file.name}: {extracted_text}")
+        else:
+            combined_context += f"\n\n---\nDocument: {uploaded_file.name}\n\n{extracted_text}"
+
+    # Chat with Gemini and use both document and web context
+    if combined_context.strip() or image_contents or question.strip():
+        with st.spinner("Generating answer..."):
+            try:
+                content_blocks = []
+
+                # Add prior Q&A as part of the context
+                if st.session_state.chat_history:
+                    history_text = "\n\n".join(
+                        f"Q: {entry['question']}\nA: {entry['answer']}"
+                        for entry in st.session_state.chat_history
+                    )
+                    content_blocks.append({"text": f"Previous conversation:\n{history_text}"})
+
+                # Add file text content
+                if combined_context.strip():
+                    content_blocks.append({"text": f"Context:\n{combined_context}"})
+
+                # Add image blocks
+                content_blocks.extend(image_contents)
+
+                # Add current question
+                content_blocks.append({"text": f"Question: {question}"})
+
+                # Add web search context
+                response = client.models.generate_content(
+                    model=MODEL_ID,
+                    contents=content_blocks,
+                    config={"tools": [{"google_search": {}}]},
+                )
+
+                st.success("💡 Answer:")
+                st.write(response.text)
+
+                # Save to session history
+                st.session_state.chat_history.append({
+                    "question": question,
+                    "answer": response.text
+                })
+
+            except Exception as e:
+                st.error(f"Error generating answer: {e}")
+    else:
+        st.warning("No valid documents or images processed.")
+
+# Optional: Show full conversation history
+if st.session_state.chat_history:
+    st.markdown("### 🗂️ Chat History")
+    for i, entry in enumerate(st.session_state.chat_history, 1):
+        st.markdown(f"**Q{i}:** {entry['question']}")
+        st.markdown(f"**A{i}:** {entry['answer']}")