app.py

import gradio as gr
import nltk
import numpy as np
import tflearn
import random
import json
import pickle
import torch
from nltk.tokenize import word_tokenize
from nltk.stem.lancaster import LancasterStemmer
from transformers import AutoTokenizer, AutoModelForSequenceClassification, pipeline
import requests
import geocoder  # Use geocoder to get latitude/longitude from city

# 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, state):
    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?"

        # Add emoticons to the response
        emoticon_dict = {
            "joy": "😊",
            "anger": "😡",
            "fear": "😨",
            "sadness": "😔",
            "surprise": "😲",
            "neutral": "😐"
        }

        # Add the emotion-related emoticon to the response
        for tg in data["intents"]:
            if tg['tag'] == tag:
                emotion = tg.get('emotion', 'neutral')  # Default to neutral if no emotion is defined
                response = f"{response} {emoticon_dict.get(emotion, '😐')}"
                break
        
        history.append((message, response))

        # Transition to the next feature (sentiment analysis)
        state['step'] = 2  # Move to sentiment analysis
    except Exception as e:
        response = f"An error occurred: {str(e)}"

    return history, history, state

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

# Function for sentiment analysis
def analyze_sentiment(text, state):
    if state is None:
        state = {'step': 1}
        
    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]
    
    # Add emoticon to sentiment
    sentiment_emojis = {
        "Negative": "😞",
        "Neutral": "😐",
        "Positive": "😊"
    }
    sentiment_with_emoji = f"{sentiment} {sentiment_emojis.get(sentiment, '😐')}"
    
    # Transition to emotion detection
    state['step'] = 3  # Move to emotion detection and suggestions
    return sentiment_with_emoji, state

# 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 emotion detection and suggestions
def detect_emotion(text, state):
    pipe = pipeline("text-classification", model=emotion_model, tokenizer=emotion_tokenizer)
    result = pipe(text)
    emotion = result[0]['label']
    
    # Provide suggestions based on detected emotion
    suggestions = provide_suggestions(emotion)
    
    # Transition to wellness professional search
    state['step'] = 4  # Move to wellness professional search
    return emotion, suggestions, state

# Suggestions based on detected emotion
def provide_suggestions(emotion):
    resources = {
        'joy': {
            'message': "You're feeling happy! Keep up the great mood! 😊",
            'articles': [
                "[Relaxation Techniques](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)",
                "[Dealing with Stress](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)"
            ],
            'videos': "[Watch Relaxation Video](https://youtu.be/m1vaUGtyo-A)"
        },
        'anger': {
            'message': "You're feeling angry. It's okay to feel this way. Let's try to calm down. 😡",
            'articles': [
                "[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)",
                "[Stress Management Tips](https://www.health.harvard.edu/health-a-to-z)"
            ],
            'videos': "[Watch Anger Management Video](https://youtu.be/MIc299Flibs)"
        },
        'fear': {
            'message': "You're feeling fearful. Take a moment to breathe and relax. 😨",
            'articles': [
                "[Mindfulness Practices](https://www.helpguide.org/mental-health/meditation/mindful-breathing-meditation)",
                "[Coping with Anxiety](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)"
            ],
            'videos': "[Watch Coping Video](https://youtu.be/yGKKz185M5o)"
        },
        'sadness': {
            'message': "You're feeling sad. It's okay to take a break. 😔",
            'articles': [
                "[Emotional Wellness Toolkit](https://www.nih.gov/health-information/emotional-wellness-toolkit)",
                "[Dealing with Anxiety](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)"
            ],
            'videos': "[Watch Sadness Relief Video](https://youtu.be/-e-4Kx5px_I)"
        },
        'surprise': {
            'message': "You're feeling surprised. It's okay to feel neutral! 😲",
            'articles': [
                "[Managing Stress](https://www.health.harvard.edu/health-a-to-z)",
                "[Coping Strategies](https://www.helpguide.org/mental-health/anxiety/tips-for-dealing-with-anxiety)"
            ],
            'videos': "[Watch Stress Relief Video](https://youtu.be/m1vaUGtyo-A)"
        }
    }
    
    # Ensure we return a message even if no articles/videos are found
    return resources.get(emotion, {'message': "Stay calm. 🙂", 'articles': ["[General Wellbeing Tips](https://www.helpguide.org)"], 'videos': []})

# Function to fetch wellness professionals based on location
def get_wellness_professionals(location):
    # Use Geocoder to get latitude/longitude from city
    g = geocoder.osm(location)
    if g.ok:
        latitude, longitude = g.latlng
        google_api_url = f"https://maps.googleapis.com/maps/api/place/nearbysearch/json?location={latitude},{longitude}&radius=5000&type=health&key=YOUR_GOOGLE_API_KEY"
        
        response = requests.get(google_api_url)
        data = response.json()
        
        professionals = []
        if 'results' in data:
            for place in data['results']:
                name = place['name']
                address = place.get('vicinity', 'No address available')
                url = place.get('website', '#')
                professionals.append(f"**{name}** - {address} - [Visit Website]({url})")
        
        if not professionals:
            professionals.append("No wellness professionals found nearby.")
        
        return "\n".join(professionals)
    else:
        return "Couldn't fetch your location. Please make sure you entered a valid location."

# Function to ask for location and provide wellness professionals
def search_wellness_professionals(location, state):
    professionals = get_wellness_professionals(location)
    state['step'] = 5  # Move to the next step
    return professionals, state

# Create the UI with location input for wellness professionals
def create_ui():
    with gr.Blocks() as demo:
        state = gr.State({'step': 1})
        chatbot = gr.Chatbot(elem_id="chatbot", label="Mental Health Chatbot")
        message_input = gr.Textbox(placeholder="Ask me something...", label="Enter your message")
        sentiment_output = gr.Textbox(placeholder="Sentiment result", label="Sentiment")
        emotion_output = gr.Textbox(placeholder="Detected emotion", label="Emotion")
        wellness_output = gr.Textbox(placeholder="Wellness professionals nearby", label="Wellness Professionals")
        location_input = gr.Textbox(placeholder="Enter your city for wellness professionals", label="Location")

        message_input.submit(chat, [message_input, chatbot, state], [chatbot, chatbot, state])
        message_input.submit(analyze_sentiment, [message_input, state], [sentiment_output, state])
        sentiment_output.submit(detect_emotion, [sentiment_output, state], [emotion_output, wellness_output, state])
        location_input.submit(search_wellness_professionals, [location_input, state], [wellness_output, state])

    return demo

# Launch Gradio interface
demo = create_ui()
demo.launch(debug=True)