app.py

import gradio as gr

import nltk

import numpy as np

import tflearn

import tensorflow

import random

import json

import pickle

import nltk

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

import torch

# 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 provide suggestions based on emotion

def provide_suggestions(emotion):

if emotion == 'joy':

return "You're feeling happy! Keep up the great mood!"

elif emotion == 'anger':

return "You're feeling angry. It's okay to feel this way. Let's try to calm down."

# Add more conditions for other emotions...

else:

return "Sorry, no suggestions available for this emotion."

# Combined function for emotion detection and suggestions

def detect_emotion_and_suggest(text):

emotion = detect_emotion(text)

suggestions = provide_suggestions(emotion)

return emotion, suggestions

# 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

# Function to find local wellness professionals

def find_wellness_professionals(location):

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:

df = pd.DataFrame(google_places_data, columns=[

"Name", "Address", "Phone", "Rating", "Business Status",

"User Ratings Total", "Website", "Types", "Latitude", "Longitude",

"Opening Hours", "Reviews", "Email"

])

return df

else:

return pd.DataFrame()

with gr.Blocks() as demo:

gr.Markdown("# Wellbeing Support System")

with gr.Tab("Chatbot"):

chatbot = gr.Chatbot()

msg = gr.Textbox()

clear = gr.Button("Clear")

msg.submit(chat, inputs=[msg, chatbot], outputs=chatbot)

clear.click(lambda: None, None, chatbot)

with gr.Tab("Sentiment Analysis"):

text_input = gr.Textbox(label="Enter text to analyze sentiment:")

analyze_button = gr.Button("Analyze Sentiment")

sentiment_output = gr.Textbox(label="Sentiment:")

analyze_button.click(analyze_sentiment, inputs=text_input, outputs=sentiment_output)

with gr.Tab("Emotion Detection & Suggestions"):

emotion_input = gr.Textbox(label="How are you feeling today?", value="Enter your thoughts here...")

detect_button = gr.Button("Detect Emotion")

emotion_output = gr.Textbox(label="Detected Emotion:")

suggestions_output = gr.Textbox(label="Suggestions:")

detect_button.click(detect_emotion_and_suggest, inputs=emotion_input, outputs=[emotion_output, suggestions_output])

with gr.Tab("Find Local Wellness Professionals"):

location_input = gr.Textbox(label="Enter your location:", value="Hawaii")

search_button = gr.Button("Search")

results_output = gr.Dataframe(label="Search Results")

search_button.click(find_wellness_professionals, inputs=location_input, outputs=results_output)

demo.launch()