app.py

import gradio as gr
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
import chromedriver_autoinstaller
import os
import nltk
import numpy as np
import torch
import torch.nn as nn
import torch.optim as optim
import tflearn
import tensorflow as tf
import json
import pickle
import random

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

# Import LancasterStemmer from nltk.stem
from nltk.stem import LancasterStemmer

# 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 = nltk.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 be 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")
model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
sentiment_pipeline = pipeline("sentiment-analysis")

def predict_sentiment(text):
    result = sentiment_pipeline(text)[0]
    return result['label']

# Emotion detection
tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
emotion_pipeline = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)

def predict_emotion(text):
    result = emotion_pipeline(text)[0]
    return result['label']

# Fetching nearby health professionals
google_places_url = "https://maps.googleapis.com/maps/api/place/textsearch/json"
google_geocoding_url = "https://maps.googleapis.com/maps/api/geocode/json"

def get_places_data(query, location, radius, api_key):
    params = {
        "query": query,
        "location": location,
        "radius": radius,
        "key": api_key
    }
    response = requests.get(google_places_url, params=params)
    return response.json()

def get_place_details(place_id, api_key):
    details_url = f"https://maps.googleapis.com/maps/api/place/details/json?place_id={place_id}&fields=name,rating,formatted_phone_number&key={api_key}"
    response = requests.get(details_url)
    return response.json()

def fetch_nearby_health_professionals(location):
    api_key = "GOOGLE_API_KEY"  # Replace with your actual Google API key
    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"
    radius = 50000  # 50 km radius
    
    response = get_places_data(query, location, radius, api_key)
    results = response.get('results', [])
    
    data = []
    for place in results:
        place_id = place['place_id']
        place_details = get_place_details(place_id, api_key)
        name = place_details.get('result', {}).get('name', 'N/A')
        rating = place_details.get('result', {}).get('rating', 'N/A')
        phone_number = place_details.get('result', {}).get('formatted_phone_number', 'N/A')
        
        data.append([name, rating, phone_number])
    
    return pd.DataFrame(data, columns=['Name', 'Rating', 'Phone Number'])

# Save results to CSV
def save_to_csv(data, filename):
    data.to_csv(filename, index=False)

# Gradio interface
with gr.Blocks() as demo:
    gr.Markdown("# Mental Health Assistant")

    # User input for text (emotion detection)
    user_input_emotion = gr.Textbox(lines=1, label="How are you feeling today?")
    submit_emotion = gr.Button("Submit")

    # Model prediction for emotion detection
    def predict_emotion(text):
        return predict_emotion(text)

    # Show suggestions based on the detected emotion
    def show_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."
        elif emotion == 'fear':
            return "You're feeling fearful. Take a moment to breathe and relax."
        elif emotion == 'sadness':
            return "You're feeling sad. It's okay to take a break."
        elif emotion == 'surprise':
            return "You're feeling surprised. It's okay to feel neutral!"

    emotion_output = gr.Textbox(label="Emotion Detected")
    submit_emotion.click(predict_emotion, inputs=user_input_emotion, outputs=emotion_output)

    # Button for summary
    def show_summary(emotion):
        return f"Emotion Detected: {emotion}"

    summary_button = gr.Button("Show Summary")
    summary_output = gr.Textbox(label="Summary")
    summary_button.click(show_summary, inputs=emotion_output, outputs=summary_output)

    # Chatbot functionality
    chatbot = gr.Chatbot(label="Chat")
    message_input = gr.Textbox(lines=1, label="Message")
    submit_chat = gr.Button("Send")

    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

    submit_chat.click(chat, inputs=[message_input, gr.State()], outputs=[chatbot, gr.State()])

    # Location input for fetching nearby health professionals
    location_input = gr.Textbox(lines=1, label="Enter your location (plain English):")
    submit_location = gr.Button("Find Nearby Health Professionals")

    # Fetch and display nearby health professionals
    def fetch_nearby_health_professionals(location):
        df = fetch_nearby_health_professionals(location)
        return df

    nearby_health_professionals_table = gr.Dataframe(headers=["Name", "Rating", "Phone Number"])
    submit_location.click(fetch_nearby_health_professionals, inputs=location_input, outputs=nearby_health_professionals_table)

    # User input for text (sentiment analysis)
    user_input_sentiment = gr.Textbox(lines=1, label="Enter text to analyze sentiment:")
    submit_sentiment = gr.Button("Submit")

    # Prediction button for sentiment analysis
    def predict_sentiment(text):
        return predict_sentiment(text)

    sentiment_output = gr.Textbox(label="Predicted Sentiment")
    submit_sentiment.click(predict_sentiment, inputs=user_input_sentiment, outputs=sentiment_output)

    # Button to fetch wellness professionals data
    fetch_button = gr.Button("Fetch Wellness Professionals Data")
    data_output = gr.Dataframe(headers=["Name", "Rating", "Phone Number"])

    def fetch_data():
        df = fetch_nearby_health_professionals("Hawaii")
        return df

    fetch_button.click(fetch_data, inputs=None, outputs=data_output)

# Launch Gradio interface
demo.launch()