app.py

import streamlit as st
import nltk
import numpy as np
import tflearn
import tensorflow
import random
import json
import pickle
import gradio as gr
from nltk.tokenize import word_tokenize
from nltk.stem.lancaster import LancasterStemmer
from transformers import AutoTokenizer, AutoModelForSequenceClassification
from transformers import pipeline
import requests
import csv
import time
import re
from bs4 import BeautifulSoup
import pandas as pd
from selenium import webdriver
from selenium.webdriver.chrome.options import Options
import chromedriver_autoinstaller
import os

# Ensure necessary NLTK resources are downloaded
nltk.download('punkt')

# Initialize the stemmer
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.")

# 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.")

# 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)
    s_words = [stemmer.stem(word.lower()) for word in s_words if word.lower() in words]
    for se in s_words:
        for i, w in enumerate(words):
            if w == se:
                bag[i] = 1
    return np.array(bag)

# Chat function
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']
                response = random.choice(responses)
                break
        else:
            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

# Load pre-trained model and tokenizer for sentiment analysis
tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
sentiment_model = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")

# Load pre-trained model and tokenizer for emotion detection
emotion_tokenizer = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
emotion_model = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")

# Function for sentiment analysis
def analyze_sentiment(text):
    inputs = tokenizer(text, return_tensors="pt")
    with torch.no_grad():
        outputs = sentiment_model(**inputs)
    predicted_class = torch.argmax(outputs.logits, dim=1).item()
    sentiment = ["Negative", "Neutral", "Positive"][predicted_class]
    return sentiment

# Function for emotion detection
def detect_emotion(text):
    pipe = pipeline("text-classification", model=emotion_model, tokenizer=emotion_tokenizer)
    result = pipe(text)
    emotion = result[0]['label']
    return emotion

# Function to scrape website URL from Google Maps using Selenium
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_by_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

# Function to scrape website for contact information
def scrape_website_for_contact_info(website):
    phone_number = "Not available"
    email = "Not available"
    try:
        response = requests.get(website, timeout=5)
        soup = BeautifulSoup(response.content, 'html.parser')
        phone_match = re.search(r'$$?\+?[0-9]*$$?[0-9_\- $$$$]*', soup.get_text())
        if phone_match:
            phone_number = phone_match.group()
        email_match = re.search(r'[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}', soup.get_text())
        if email_match:
            email = email_match.group()
    except Exception as e:
        print(f"Error scraping website {website}: {e}")
    return phone_number, email

# Function to fetch detailed information for a specific place using its place_id
def get_place_details(place_id, api_key):
    details_url = "https://maps.googleapis.com/maps/api/place/details/json"
    params = {
        "place_id": place_id,
        "key": api_key
    }
    response = requests.get(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 {}

# Function to get all places data including pagination
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)
        if data:
            results = data.get('results', [])
            for place in results:
                place_id = place.get("place_id")
                name = place.get("name")
                address = place.get("formatted_address")
                rating = place.get("rating", "Not available")
                business_status = place.get("business_status", "Not available")
                user_ratings_total = place.get("user_ratings_total", "Not available")
                website = place.get("website", "Not available")
                types = ", ".join(place.get("types", []))
                location = place.get("geometry", {}).get("location", {})
                latitude = location.get("lat", "Not available")
                longitude = location.get("lng", "Not available")
                details = get_place_details(place_id, api_key)
                phone_number = details.get("phone_number", "Not available")
                if phone_number == "Not available" and website != "Not available":
                    phone_number, email = scrape_website_for_contact_info(website)
                else:
                    email = "Not available"
                if website == "Not available":
                    website = scrape_website_from_google_maps(name)
                all_results.append([name, address, phone_number, rating, business_status,
                                    user_ratings_total, website, types, latitude, longitude,
                                    details.get("opening_hours", "Not available"),
                                    details.get("reviews", "Not available"), email
                                    ])
            next_page_token = data.get('next_page_token')
            if not next_page_token:
                break
            time.sleep(2)
        else:
            break
    return all_results

# Function to save results to CSV file
def save_to_csv(data, filename):
    with open(filename, mode='w', newline='', encoding='utf-8') as file:
        writer = csv.writer(file)
        writer.writerow([
            "Name", "Address", "Phone", "Rating", "Business Status",
            "User Ratings Total", "Website", "Types", "Latitude", "Longitude",
            "Opening Hours", "Reviews", "Email"
        ])
        writer.writerows(data)
    print(f"Data saved to {filename}")

# Function to get places data from Google Places API
def get_places_data(query, location, radius, api_key, next_page_token=None):
    url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
    params = {
        "query": query,
        "location": location,
        "radius": radius,
        "key": api_key
    }
    if next_page_token:
        params["pagetoken"] = next_page_token
    response = requests.get(url, params=params)
    if response.status_code == 200:
        data = response.json()
        return data
    else:
        print(f"Error: {response.status_code} - {response.text}")
        return None

# Set page config
st.set_page_config(page_title="Wellbeing Support System", layout="wide")

# Display header
st.title("Wellbeing Support System")

# User input for location
location = st.text_input("Enter your location:", "Hawaii")

# Tabs for different functionalities
tabs = ["Chatbot", "Sentiment Analysis", "Emotion Detection & Suggestions", "Find Local Wellness Professionals"]
selected_tab = st.selectbox("Select a functionality:", tabs)

if selected_tab == "Chatbot":
    # Chatbot functionality
    st.subheader("Chat with the Mental Health Support Bot")
    chatbot = gr.Chatbot(label="Chat")
    demo = gr.Interface(
        chat,
        [gr.Textbox(lines=1, label="Message"), "state"],
        [chatbot, "state"],
        allow_flagging="never",
        title="Wellbeing for All, ** I am your Best Friend **",
    )
    demo.launch()

elif selected_tab == "Sentiment Analysis":
    # Sentiment Analysis
    st.subheader("Sentiment Analysis")
    user_input = st.text_area("Enter text to analyze sentiment:")
    if st.button("Analyze Sentiment"):
        if user_input:
            sentiment = analyze_sentiment(user_input)
            st.write(f"**Sentiment:** {sentiment}")
        else:
            st.warning("Please enter some text to analyze.")

elif selected_tab == "Emotion Detection & Suggestions":
    # Emotion Detection and Suggestions
    st.subheader("Emotion Detection and Well-Being Suggestions")
    user_input = st.text_area("How are you feeling today?", "Enter your thoughts here...")
    if st.button("Detect Emotion"):
        if user_input:
            emotion = detect_emotion(user_input)
            st.write(f"**Emotion Detected:** {emotion}")
            # Provide suggestions based on the detected emotion
            if emotion == 'joy':
                st.write("You're feeling happy! Keep up the great mood!")
                st.write("Useful Resources:")
                st.markdown("[Relaxation Techniques](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)")
                st.write("[Dealing with Stress](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)")
                st.write("[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)")
                st.write("Relaxation Videos:")
                st.markdown("[Watch on YouTube](https://youtu.be/m1vaUGtyo-A)")
            elif emotion == 'anger':
                st.write("You're feeling angry. It's okay to feel this way. Let's try to calm down.")
                st.write("Useful Resources:")
                st.markdown("[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)")
                st.write("[Stress Management Tips](https://www.health.harvard.edu/health-a-to-z)")
                st.write("[Dealing with Anger](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)")
                st.write("Relaxation Videos:")
                st.markdown("[Watch on YouTube](https://youtu.be/MIc299Flibs)")
            # Add more conditions for other emotions...
        else:
            st.warning("Please enter some text to analyze.")

elif selected_tab == "Find Local Wellness Professionals":
    # Find Local Wellness Professionals
    st.subheader("Find Local Wellness Professionals")
    if st.button("Search"):
        # Define search parameters
        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 in " + location
        api_key = "AIzaSyCcfJzMFfuv_1LN7JPTJJYw_aS0A_SLeW0"  # Replace with your own Google API key
        location_coords = "21.3,-157.8"  # Default to Oahu, Hawaii
        radius = 50000  # 50 km radius

        # Install Chrome and Chromedriver
        def install_chrome_and_driver():
            os.system("apt-get update")
            os.system("apt-get install -y wget curl")
            os.system("wget -q https://dl.google.com/linux/direct/google-chrome-stable_current_amd64.deb")
            os.system("dpkg -i google-chrome-stable_current_amd64.deb")
            os.system("apt-get install -y -f")
            os.system("google-chrome-stable --version")
            chromedriver_autoinstaller.install()

        install_chrome_and_driver()

        # Get all places data
        google_places_data = get_all_places(query, location_coords, radius, api_key)
        if google_places_data:
            # Display the results
            df = pd.DataFrame(google_places_data, columns=[
                "Name", "Address", "Phone", "Rating", "Business Status",
                "User Ratings Total", "Website", "Types", "Latitude", "Longitude",
                "Opening Hours", "Reviews", "Email"
            ])
            st.write(df)
            # Save to CSV
            save_to_csv(google_places_data, "wellness_professionals.csv")
        else:
            st.write("No data found.")