Update app.py

app.py

@@ -1,5 +1,8 @@
+# app.py
+
 import os
 import time
+import threading
 import streamlit as st
 from twilio.rest import Client
 from pdfminer.high_level import extract_text
@@ -11,16 +14,14 @@ import docx
 from groq import Groq
 import PyPDF2
 import requests
-from streamlit_autorefresh import st_autorefresh
 
-# Extract text from PDF
+# --- Text Extraction Utilities ---
 def extract_text_from_pdf(pdf_path):
     try:
         text = ""
         with open(pdf_path, 'rb') as file:
-            pdf_reader = PyPDF2.PdfReader(file)
-            for page_num in range(len(pdf_reader.pages)):
-                page = pdf_reader.pages[page_num]
+            reader = PyPDF2.PdfReader(file)
+            for page in reader.pages:
                 page_text = page.extract_text()
                 if page_text:
                     text += page_text
@@ -35,6 +36,7 @@ def extract_text_from_docx(docx_path):
     except:
         return ""
 
+# --- Chunking & Retrieval ---
 def chunk_text(text, tokenizer, chunk_size=150, chunk_overlap=30):
     tokens = tokenizer.tokenize(text)
     chunks, start = [], 0
@@ -46,16 +48,14 @@ def chunk_text(text, tokenizer, chunk_size=150, chunk_overlap=30):
     return chunks
 
 def retrieve_chunks(question, index, embed_model, text_chunks, k=3):
-    question_embedding = embed_model.encode([question])[0]
-    D, I = index.search(np.array([question_embedding]), k)
+    q_embedding = embed_model.encode([question])[0]
+    D, I = index.search(np.array([q_embedding]), k)
     return [text_chunks[i] for i in I[0]]
 
-def generate_answer_with_groq(question, context, retries=3, delay=2):
+# --- Groq Answer Generator ---
+def generate_answer_with_groq(question, context):
     url = "https://api.groq.com/openai/v1/chat/completions"
     api_key = os.environ.get("GROQ_API_KEY")
-    if not api_key:
-        return "⚠️ GROQ_API_KEY not set."
-
     headers = {
         "Authorization": f"Bearer {api_key}",
         "Content-Type": "application/json",
@@ -74,7 +74,6 @@ def generate_answer_with_groq(question, context, retries=3, delay=2):
                     "You are ToyBot, a friendly and helpful WhatsApp assistant for an online toy shop. "
                     "Your goal is to politely answer customer questions, help them choose the right toys, "
                     "provide order or delivery information, explain return policies, and guide them through purchases. "
-                    "Always sound warm, helpful, and trustworthy like a professional customer support agent."
                 )
             },
             {"role": "user", "content": prompt},
@@ -82,124 +81,103 @@ def generate_answer_with_groq(question, context, retries=3, delay=2):
         "temperature": 0.5,
         "max_tokens": 300,
     }
+    response = requests.post(url, headers=headers, json=payload)
+    response.raise_for_status()
+    return response.json()['choices'][0]['message']['content'].strip()
 
-    for attempt in range(retries):
-        try:
-            response = requests.post(url, headers=headers, json=payload, timeout=10)
-            response.raise_for_status()
-            result = response.json()
-            return result['choices'][0]['message']['content'].strip()
-        except requests.exceptions.HTTPError as e:
-            if response.status_code == 503 and attempt < retries - 1:
-                time.sleep(delay)
-                continue
-            else:
-                return f"⚠️ Groq API HTTPError: {e}"
-        except Exception as e:
-            return f"⚠️ Groq API Error: {e}"
-
-def fetch_latest_incoming_message(client, conversation_sid):
-    messages = client.conversations.v1.conversations(conversation_sid).messages.list(limit=10)
-    for msg in reversed(messages):
-        if msg.author.startswith("whatsapp:"):
-            return msg.body, msg.author, msg.index
-    return None, None, None
-
-def send_twilio_message(client, conversation_sid, body):
-    try:
-        message = client.conversations.v1.conversations(conversation_sid).messages.create(author="system", body=body)
-        return message.sid
-    except Exception as e:
-        return str(e)
-
-# Automatically get the latest WhatsApp conversation SID
+# --- Twilio Functions ---
 def get_latest_whatsapp_conversation_sid(client):
     conversations = client.conversations.v1.conversations.list(limit=20)
     for convo in conversations:
         try:
             participants = client.conversations.v1.conversations(convo.sid).participants.list()
             for p in participants:
-                if p.identity and p.identity.startswith("whatsapp:"):
-                    return convo.sid
-                if p.messaging_binding and p.messaging_binding.get("address", "").startswith("whatsapp:"):
+                if (p.identity and p.identity.startswith("whatsapp:")) or (
+                    p.messaging_binding and p.messaging_binding.get("address", "").startswith("whatsapp:")
+                ):
                     return convo.sid
-        except Exception as e:
+        except:
             continue
     return conversations[0].sid if conversations else None
 
+def fetch_latest_incoming_message(client, conversation_sid):
+    messages = client.conversations.v1.conversations(conversation_sid).messages.list(limit=10)
+    for msg in reversed(messages):
+        if msg.author.startswith("whatsapp:"):
+            return msg.body, msg.author, msg.index
+    return None, None, None
+
+def send_twilio_message(client, conversation_sid, body):
+    return client.conversations.v1.conversations(conversation_sid).messages.create(
+        author="system", body=body
+    )
 
-# Streamlit UI
+# --- Load Knowledge Base ---
+def setup_knowledge_base():
+    folder_path = "docs"
+    all_text = ""
+    for file in os.listdir(folder_path):
+        path = os.path.join(folder_path, file)
+        if file.endswith(".pdf"):
+            all_text += extract_text_from_pdf(path) + "\n"
+        elif file.endswith((".docx", ".doc")):
+            all_text += extract_text_from_docx(path) + "\n"
+    tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
+    chunks = chunk_text(all_text, tokenizer)
+    model = SentenceTransformer('all-mpnet-base-v2')
+    embeddings = model.encode(chunks)
+    dim = embeddings[0].shape[0]
+    index = faiss.IndexFlatL2(dim)
+    index.add(np.array(embeddings).astype('float32'))
+    return index, model, chunks
+
+# --- Background Polling Thread ---
+def start_message_monitor(client, convo_sid, index, embed_model, text_chunks):
+    last_index = -1
+
+    def poll_loop():
+        nonlocal last_index
+        while True:
+            try:
+                question, sender, msg_index = fetch_latest_incoming_message(client, convo_sid)
+                if question and msg_index > last_index:
+                    last_index = msg_index
+                    print(f"\n📥 New Message from {sender}: {question}")
+                    context = "\n\n".join(retrieve_chunks(question, index, embed_model, text_chunks))
+                    answer = generate_answer_with_groq(question, context)
+                    send_twilio_message(client, convo_sid, answer)
+                    print(f"📤 Sent Reply: {answer}")
+                time.sleep(3)
+            except Exception as e:
+                print("❌ Error in polling loop:", e)
+                time.sleep(5)
+
+    thread = threading.Thread(target=poll_loop, daemon=True)
+    thread.start()
+
+# --- Streamlit UI ---
 st.set_page_config(page_title="Quasa – A Smart WhatsApp Chatbot", layout="wide")
 st.title("📱 Quasa – A Smart WhatsApp Chatbot")
 
-if "last_index" not in st.session_state:
-    st.session_state.last_index = -1
-
 account_sid = st.secrets.get("TWILIO_SID")
 auth_token = st.secrets.get("TWILIO_TOKEN")
 GROQ_API_KEY = st.secrets.get("GROQ_API_KEY")
 
 if not all([account_sid, auth_token, GROQ_API_KEY]):
-    st.warning("⚠️ Some secrets not found. Please enter missing credentials below:")
+    st.warning("⚠️ Provide all credentials below:")
     account_sid = st.text_input("Twilio SID", value=account_sid or "")
-    auth_token = st.text_input("Twilio Auth Token", type="password", value=auth_token or "")
+    auth_token = st.text_input("Twilio Token", type="password", value=auth_token or "")
     GROQ_API_KEY = st.text_input("GROQ API Key", type="password", value=GROQ_API_KEY or "")
 
-enable_autorefresh = st.checkbox("🔄 Enable Auto-Refresh", value=True)
-interval_seconds = st.selectbox("Refresh Interval (seconds)", options=[5, 10, 15, 30, 60], index=4)
-
-if enable_autorefresh:
-    st_autorefresh(interval=interval_seconds * 1000, key="auto-refresh")
-
 if all([account_sid, auth_token, GROQ_API_KEY]):
     os.environ["GROQ_API_KEY"] = GROQ_API_KEY
     client = Client(account_sid, auth_token)
     conversation_sid = get_latest_whatsapp_conversation_sid(client)
 
-    if conversation_sid is None:
+    if conversation_sid:
+        st.success("✅ WhatsApp connected. Initializing chatbot...")
+        index, model, chunks = setup_knowledge_base()
+        start_message_monitor(client, conversation_sid, index, model, chunks)
+        st.success("🟢 Chatbot is running in background and will reply automatically.")
+    else:
         st.error("❌ No WhatsApp conversation found.")
-        st.stop()
-
-    @st.cache_data(show_spinner=False)
-    def setup_knowledge_base():
-        folder_path = "docs"
-        all_text = ""
-        try:
-            for file in os.listdir(folder_path):
-                if file.endswith(".pdf"):
-                    all_text += extract_text_from_pdf(os.path.join(folder_path, file)) + "\n"
-                elif file.endswith((".docx", ".doc")):
-                    all_text += extract_text_from_docx(os.path.join(folder_path, file)) + "\n"
-            tokenizer = AutoTokenizer.from_pretrained('bert-base-uncased')
-            chunks = chunk_text(all_text, tokenizer)
-            model = SentenceTransformer('all-mpnet-base-v2')
-            embeddings = model.encode(chunks)
-            dim = embeddings[0].shape[0]
-            index = faiss.IndexFlatL2(dim)
-            index.add(np.array(embeddings).astype('float32'))
-            return index, model, chunks
-        except Exception as e:
-            st.error(f"Error setting up knowledge base: {e}")
-            return None, None, None
-
-    index, embedding_model, text_chunks = setup_knowledge_base()
-    if index is None:
-        st.stop()
-
-    st.success("✅ Knowledge base ready. Monitoring WhatsApp...")
-
-    with st.spinner("⏳ Checking for new WhatsApp messages..."):
-        question, sender, msg_index = fetch_latest_incoming_message(client, conversation_sid)
-        if question and msg_index > st.session_state.last_index:
-            st.session_state.last_index = msg_index
-            st.info(f"📥 New Question from {sender}:\n\n> {question}")
-            relevant_chunks = retrieve_chunks(question, index, embedding_model, text_chunks)
-            context = "\n\n".join(relevant_chunks)
-            answer = generate_answer_with_groq(question, context)
-            send_twilio_message(client, conversation_sid, answer)
-            st.success("📤 Answer sent via WhatsApp!")
-            st.markdown(f"### ✨ Answer:\n\n{answer}")
-        else:
-            st.caption("✅ No new message yet. Waiting for refresh...")
-else:
-    st.warning("❗ Please provide all required credentials.")