Update app.py

app.py

@@ -8,46 +8,55 @@ import pickle
 import torch
 from nltk.tokenize import word_tokenize
 from nltk.stem.lancaster import LancasterStemmer
-from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
 import requests
 import pandas as pd
 import os
+from bs4 import BeautifulSoup
+from selenium import webdriver
+from selenium.webdriver.chrome.options import Options
+import chromedriver_autoinstaller
 
 # Ensure necessary NLTK resources are downloaded
 nltk.download('punkt')
 
-# Initialize the stemmer
+# --- Constants ---
+GOOGLE_MAPS_API_KEY = os.environ.get("GOOGLE_MAPS_API_KEY")  # Get API key from environment variable
+if not GOOGLE_MAPS_API_KEY:
+    raise ValueError("Error: GOOGLE_MAPS_API_KEY environment variable not set.")
+
+url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
+places_details_url = "https://maps.googleapis.com/maps/api/place/details/json"
+query = "therapist OR counselor OR mental health professional OR marriage and family therapist OR psychotherapist OR psychiatrist OR psychologist OR nutritionist OR wellness doctor OR holistic practitioner OR integrative medicine OR chiropractor OR naturopath"
+
+
+# --- Chatbot Logic ---
 stemmer = LancasterStemmer()
 
-# Load intents.json
 try:
     with open("intents.json") as file:
         data = json.load(file)
 except FileNotFoundError:
-    raise FileNotFoundError("Error: 'intents.json' file not found. Ensure it exists in the current directory.")
+    raise FileNotFoundError("Error: 'intents.json' file not found.")
 
-# Load preprocessed data from pickle
 try:
     with open("data.pickle", "rb") as f:
         words, labels, training, output = pickle.load(f)
 except FileNotFoundError:
-    raise FileNotFoundError("Error: 'data.pickle' file not found. Ensure it exists and matches the model.")
+    raise FileNotFoundError("Error: 'data.pickle' file not found.")
 
-# Build the model structure
 net = tflearn.input_data(shape=[None, len(training[0])])
 net = tflearn.fully_connected(net, 8)
 net = tflearn.fully_connected(net, 8)
 net = tflearn.fully_connected(net, len(output[0]), activation="softmax")
 net = tflearn.regression(net)
 
-# Load the trained model
 model = tflearn.DNN(net)
 try:
     model.load("MentalHealthChatBotmodel.tflearn")
 except FileNotFoundError:
     raise FileNotFoundError("Error: Trained model file 'MentalHealthChatBotmodel.tflearn' not found.")
 
-# Function to process user input into a bag-of-words format
 def bag_of_words(s, words):
     bag = [0 for _ in range(len(words))]
     s_words = word_tokenize(s)
@@ -58,18 +67,13 @@ def bag_of_words(s, words):
                 bag[i] = 1
     return np.array(bag)
 
-# Chat function (Chatbot)
 def chat(message, history):
     history = history or []
     message = message.lower()
-    
     try:
-        # Predict the tag
         results = model.predict([bag_of_words(message, words)])
         results_index = np.argmax(results)
         tag = labels[results_index]
-
-        # Match tag with intent and choose a random response
         for tg in data["intents"]:
             if tg['tag'] == tag:
                 responses = tg['responses']
@@ -79,83 +83,35 @@ def chat(message, history):
             response = "I'm sorry, I didn't understand that. Could you please rephrase?"
     except Exception as e:
         response = f"An error occurred: {str(e)}"
-    
     history.append((message, response))
     return history, history
 
-# Sentiment Analysis
-tokenizer_sentiment = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
+# --- Sentiment Analysis ---
+tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
 model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
 
-def analyze_sentiment(user_input):
-    inputs = tokenizer_sentiment(user_input, return_tensors="pt")
-    with torch.no_grad():
-        outputs = model_sentiment(**inputs)
-    predicted_class = torch.argmax(outputs.logits, dim=1).item()
-    sentiment = ["Negative", "Neutral", "Positive"][predicted_class]
-    return f"**Predicted Sentiment:** {sentiment}"
-
-# Emotion Detection
-tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
-pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
+def analyze_sentiment(text):
+    try:
+        inputs = tokenizer(text, return_tensors="pt", truncation=True, padding=True)
+        with torch.no_grad():
+            outputs = model_sentiment(**inputs)
+        predicted_class = torch.argmax(outputs.logits, dim=1).item()
+        sentiment = ["Negative", "Neutral", "Positive"][predicted_class]
+        return f"**Predicted Sentiment:** {sentiment}"
+    except Exception as e:
+        return f"Error analyzing sentiment: {str(e)}"
 
-def detect_emotion(user_input):
-    result = pipe(user_input)
-    emotion = result[0]['label']
-    return emotion
+# --- Emotion Detection (Placeholder) ---
+def detect_emotion(text):
+    # Replace with your actual emotion detection logic
+    return "Emotion detection not implemented"
 
+# --- Suggestion Generation (Placeholder) ---
 def provide_suggestions(emotion):
-    suggestions = pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])
-
-    if emotion == 'joy':
-        suggestions = suggestions.append({
-            "Subject": "Relaxation Techniques",
-            "Article URL": "https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation",
-            "Video URL": "https://youtu.be/m1vaUGtyo-A"
-        }, ignore_index=True)
-        suggestions = suggestions.append({
-            "Subject": "Dealing with Stress",
-            "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety",
-            "Video URL": "https://youtu.be/MIc299Flibs"
-        }, ignore_index=True)
-
-    elif emotion == 'anger':
-        suggestions = suggestions.append({
-            "Subject": "Managing Anger",
-            "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety",
-            "Video URL": "https://youtu.be/MIc299Flibs"
-        }, ignore_index=True)
-
-    elif emotion == 'fear':
-        suggestions = suggestions.append({
-            "Subject": "Coping with Anxiety",
-            "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety",
-            "Video URL": "https://youtu.be/yGKKz185M5o"
-        }, ignore_index=True)
-
-    elif emotion == 'sadness':
-        suggestions = suggestions.append({
-            "Subject": "Dealing with Sadness",
-            "Article URL": "https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety",
-            "Video URL": "https://youtu.be/-e-4Kx5px_I"
-        }, ignore_index=True)
-
-    elif emotion == 'surprise':
-        suggestions = suggestions.append({
-            "Subject": "Managing Stress",
-            "Article URL": "https://www.health.harvard.edu/health-a-to-z",
-            "Video URL": "https://youtu.be/m1vaUGtyo-A"
-        }, ignore_index=True)
-        
-    return suggestions
-
-# Google Places API integration
-api_key = os.environ.get("GOOGLE_API_KEY") # Get API key from environment variable
-
-url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
-places_details_url = "https://maps.googleapis.com/maps/api/place/details/json"
+    # Replace with your actual suggestion generation logic
+    return pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])
 
+# --- Google Places API Functions ---
 def get_places_data(query, location, radius, api_key, next_page_token=None):
     params = {
         "query": query,
@@ -166,39 +122,55 @@ def get_places_data(query, location, radius, api_key, next_page_token=None):
     if next_page_token:
         params["pagetoken"] = next_page_token
     response = requests.get(url, params=params)
-    return response.json() if response.status_code == 200 else None
+    if response.status_code == 200:
+        return response.json()
+    else:
+        print(f"Error: {response.status_code} - {response.text}")
+        return None
 
 def get_place_details(place_id, api_key):
-    params = {
-        "place_id": place_id,
-        "key": api_key
-    }
+    params = {"place_id": place_id, "key": api_key}
     response = requests.get(places_details_url, params=params)
     if response.status_code == 200:
         details_data = response.json().get("result", {})
         return {
-            "opening_hours": details_data.get("opening_hours", {}).get("weekday_text", "Not available"),
-            "reviews": details_data.get("reviews", "Not available"),
             "phone_number": details_data.get("formatted_phone_number", "Not available"),
             "website": details_data.get("website", "Not available")
         }
     else:
         return {}
 
+def scrape_website_from_google_maps(place_name):
+    chrome_options = Options()
+    chrome_options.add_argument("--headless")
+    chrome_options.add_argument("--no-sandbox")
+    chrome_options.add_argument("--disable-dev-shm-usage")
+    driver = webdriver.Chrome(options=chrome_options)
+    search_url = f"https://www.google.com/maps/search/{place_name.replace(' ', '+')}"
+    driver.get(search_url)
+    time.sleep(5)
+    try:
+        website_element = driver.find_element("xpath", '//a[contains(@aria-label, "Visit") and contains(@aria-label, "website")]')
+        website_url = website_element.get_attribute('href')
+    except:
+        website_url = "Not available"
+    driver.quit()
+    return website_url
+
 def get_all_places(query, location, radius, api_key):
     all_results = []
     next_page_token = None
     while True:
-        data = get_places_data(query, location, radius, api_key, next_page_token)
+        data = get_places_data(query + f" in {location}", location, radius, api_key, next_page_token)
         if data:
             results = data.get('results', [])
             for place in results:
-                place_id = place.get("place_id", "N/A") # Handle missing place_id
-                name = place.get("name", "N/A") # Handle missing name
-                address = place.get("formatted_address", "N/A") # Handle missing address
-                website = place.get("website", "Not available")
-                details = get_place_details(place_id, api_key) if place_id != "N/A" else {} #Avoid error if place_id is missing
+                place_id = place.get("place_id")
+                name = place.get("name")
+                address = place.get("formatted_address")
+                details = get_place_details(place_id, api_key)
                 phone_number = details.get("phone_number", "Not available")
+                website = details.get("website", "Not available")
                 all_results.append([name, address, phone_number, website])
             next_page_token = data.get('next_page_token')
             if not next_page_token:
@@ -207,50 +179,67 @@ def get_all_places(query, location, radius, api_key):
             break
     return all_results
 
-def search_wellness_professionals(location):
-    query = "therapist OR counselor OR mental health professional"
-    radius = 50000
-    try:
-        google_places_data = get_all_places(query, location, radius, api_key)
-        if google_places_data:
-            df = pd.DataFrame(google_places_data, columns=["Name", "Address", "Phone", "Website"])
-            return df
+# --- Gradio Interface ---
+def gradio_interface(message, location, state, btn_chat, btn_search):
+    history = state or []
+    if len(history) == 0:
+        if btn_chat:
+            history, _ = chat(message, history)
+            sentiment = analyze_sentiment(message)
+            emotion = detect_emotion(message)
+            suggestions = provide_suggestions(emotion)
+            if location:
+                try:
+                    wellness_results = pd.DataFrame(get_all_places(query, location, 50000, GOOGLE_MAPS_API_KEY), columns=["Name", "Address", "Phone", "Website"])
+                except Exception as e:
+                    wellness_results = pd.DataFrame([["Error fetching data: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
+            else:
+                wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
         else:
-            return pd.DataFrame([["No data found.", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
-    except Exception as e:
-        return pd.DataFrame([["Error fetching data: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
-
+            history = history
+            sentiment = ""
+            emotion = ""
+            suggestions = pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])
+            wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
+    elif len(history) > 0 and location == "":
+        if btn_chat:
+            history, _ = chat(message, history)
+            sentiment = analyze_sentiment(message)
+            emotion = detect_emotion(message)
+            suggestions = provide_suggestions(emotion)
+            wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
+        else:
+            history = history
+            sentiment = ""
+            emotion = ""
+            suggestions = pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])
+            wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
+    elif len(history) > 0 and location != "" and btn_search:
+        try:
+            wellness_results = pd.DataFrame(get_all_places(query, location, 50000, GOOGLE_MAPS_API_KEY), columns=["Name", "Address", "Phone", "Website"])
+            sentiment = analyze_sentiment(message)
+            emotion = detect_emotion(message)
+            suggestions = provide_suggestions(emotion)
+            history, _ = chat(message, history)
+        except Exception as e:
+            wellness_results = pd.DataFrame([["Error: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
+    else:
+        history = history
+        sentiment = ""
+        emotion = ""
+        suggestions = pd.DataFrame(columns=["Subject", "Article URL", "Video URL"])
+        wellness_results = pd.DataFrame([["", "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
 
-# Gradio Interface
-def gradio_interface(message, location, state):
-    history = state or []  # If state is None, initialize it as an empty list
-    
-    # Stage 1: Mental Health Chatbot
-    history, _ = chat(message, history)
-    
-    # Stage 2: Sentiment Analysis
-    sentiment = analyze_sentiment(message)
-    
-    # Stage 3: Emotion Detection and Suggestions
-    emotion = detect_emotion(message)
-    suggestions = provide_suggestions(emotion)
-    
-    # Stage 4: Search for Wellness Professionals
-    try:
-        wellness_results = search_wellness_professionals(location)
-    except Exception as e:
-        wellness_results = pd.DataFrame([["Error: " + str(e), "", "", ""]], columns=["Name", "Address", "Phone", "Website"])
-    
-    # Return the results in a tabular form within the Gradio interface
-    return history, sentiment, emotion, suggestions, wellness_results, history  # Last 'history' is for state
+    return history, sentiment, emotion, suggestions, wellness_results, history
 
-# Gradio interface setup
 iface = gr.Interface(
     fn=gradio_interface,
     inputs=[
         gr.Textbox(label="Enter your message", placeholder="How are you feeling today?"),
-        gr.Textbox(label="Enter your location (e.g., 'Hawaii, USA')", placeholder="Enter your location"),
-        gr.State()  # To maintain state (chat history)
+        gr.Textbox(label="Enter your location (e.g., 'Hawaii, USA')", placeholder="Enter your location (optional)"),
+        gr.State(),
+        gr.Button("Chat"),
+        gr.Button("Search")
     ],
     outputs=[
         gr.Chatbot(label="Chatbot Responses"),
@@ -258,16 +247,11 @@ iface = gr.Interface(
         gr.Textbox(label="Emotion Detected"),
         gr.DataFrame(label="Suggested Articles & Videos"),
         gr.DataFrame(label="Nearby Wellness Professionals"),
-        gr.State()  # To maintain state (chat history)
+        gr.State()
     ],
     live=True,
     title="Mental Health Chatbot with Wellness Professional Search",
-    description="This chatbot provides mental health support with sentiment analysis, emotion detection, suggestions, and a list of nearby wellness professionals."
+    description="This chatbot provides mental health support with sentiment analysis, emotion detection, suggestions, and a list of nearby wellness professionals. Interact with the chatbot first, then enter a location to search."
 )
 
-# Check for API key; if not found, print an error message
-if api_key is None:
-    print("Error: GOOGLE_MAPS_API_KEY environment variable not set. Please set this environment variable with your Google Maps API key.")
-
-# Launch the interface
 iface.launch(debug=True, share=True)