Update app.py

app.py

@@ -24,18 +24,12 @@ nltk.download('punkt')
 stemmer = LancasterStemmer()
 
 # Load intents.json for Well-Being Chatbot
-try:
-    with open("intents.json") as file:
-        data = json.load(file)
-except FileNotFoundError:
-    print("Error: 'intents.json' file not found.")
+with open("intents.json") as file:
+    data = json.load(file)
 
 # Load preprocessed data for Well-Being Chatbot
-try:
-    with open("data.pickle", "rb") as f:
-        words, labels, training, output = pickle.load(f)
-except FileNotFoundError:
-    print("Error: 'data.pickle' file not found.")
+with open("data.pickle", "rb") as f:
+    words, labels, training, output = pickle.load(f)
 
 # Build the model structure for Well-Being Chatbot
 net = tflearn.input_data(shape=[None, len(training[0])])
@@ -46,10 +40,7 @@ net = tflearn.regression(net)
 
 # Load the trained model
 model = tflearn.DNN(net)
-try:
-    model.load("MentalHealthChatBotmodel.tflearn")
-except IOError:
-    print("Error: Model file not found or corrupted.")
+model.load("MentalHealthChatBotmodel.tflearn")
 
 # Function to process user input into a bag-of-words format for Chatbot
 def bag_of_words(s, words):
@@ -94,63 +85,61 @@ tokenizer = AutoTokenizer.from_pretrained("cardiffnlp/twitter-roberta-base-senti
 model_sentiment = AutoModelForSequenceClassification.from_pretrained("cardiffnlp/twitter-roberta-base-sentiment")
 
 def analyze_sentiment(user_input):
-    try:
-        inputs = tokenizer(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}"
-    except Exception as e:
-        return f"Sentiment analysis error: {str(e)}"
+    inputs = tokenizer(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]  # Assuming 3 classes
+    return f"Predicted Sentiment: {sentiment}"
 
 # Emotion Detection using Hugging Face model
 tokenizer_emotion = AutoTokenizer.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
 model_emotion = AutoModelForSequenceClassification.from_pretrained("j-hartmann/emotion-english-distilroberta-base")
 
 def detect_emotion(user_input):
-    try:
-        pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
-        result = pipe(user_input)
-        emotion = result[0]['label']
-        return f"Emotion Detected: {emotion}"
-    except Exception as e:
-        return f"Emotion detection error: {str(e)}"
+    pipe = pipeline("text-classification", model=model_emotion, tokenizer=tokenizer_emotion)
+    result = pipe(user_input)
+    emotion = result[0]['label']
+    return f"Emotion Detected: {emotion}"
 
 # Initialize Google Maps API client securely
 gmaps = googlemaps.Client(key=os.getenv('GOOGLE_API_KEY'))
 
 # Function to search for health professionals
 def search_health_professionals(query, location, radius=10000):
-    try:
-        places_result = gmaps.places_nearby(location, radius=radius, type='doctor', keyword=query)
-        if 'results' in places_result:
-            return places_result['results']
-        else:
-            return []
-    except Exception as e:
-        print(f"Error fetching health professionals: {str(e)}")
-        return []
+    places_result = gmaps.places_nearby(location, radius=radius, type='doctor', keyword=query)
+    return places_result.get('results', [])
 
 # Function to get directions and display on Gradio UI
 def get_health_professionals_and_map(current_location, health_professional_query):
-    # Get health professionals using the search function
-    health_professionals = search_health_professionals(health_professional_query, current_location)
-    
-    # Generate the map with the professionals' locations
-    map_obj = folium.Map(location=current_location, zoom_start=13)
-    for professional in health_professionals:
-        location = professional['geometry']['location']
-        folium.Marker([location['lat'], location['lng']], popup=professional['name']).add_to(map_obj)
-    
-    # Save the map to an HTML file
-    map_html = "health_professionals_map.html"
-    map_obj.save(map_html)
-    
-    # Generate route information (basic for now)
-    route_info = [f"{hp['name']} - {hp['vicinity']}" for hp in health_professionals]
-    
-    return route_info, map_html
+    location = gmaps.geocode(current_location)
+    if location:
+        lat = location[0]["geometry"]["location"]["lat"]
+        lng = location[0]["geometry"]["location"]["lng"]
+        location = (lat, lng)
+        
+        professionals = search_health_professionals(health_professional_query, location)
+        
+        # Generate map
+        map_center = location
+        m = folium.Map(location=map_center, zoom_start=13)
+        
+        # Add markers to the map
+        for place in professionals:
+            folium.Marker(
+                location=[place['geometry']['location']['lat'], place['geometry']['location']['lng']],
+                popup=place['name']
+            ).add_to(m)
+        
+        # Convert map to HTML for Gradio display
+        map_html = m._repr_html_()
+        
+        # Route information
+        route_info = "\n".join([f"{place['name']} - {place['vicinity']}" for place in professionals])
+        
+        return route_info, map_html
+    else:
+        return "Unable to find location.", ""
 
 # Function to generate suggestions based on the detected emotion
 def generate_suggestions(emotion):
@@ -184,14 +173,55 @@ def generate_suggestions(emotion):
             {"Title": "Relaxation Video", "Subject": "Video", "Link": "https://youtu.be/m1vaUGtyo-A"}
         ]
     }
-    
     return suggestions.get(emotion.lower(), [])
 
-# Define the Gradio interface
-iface = gr.Interface(fn=chatbot,
-                     inputs=[gr.Textbox(label="Message"),
-                             gr.State()],
-                     outputs=[gr.Chatbot(), gr.State()],
-                     allow_flagging="never", theme="compact")
-
+# Gradio interface
+def gradio_app(message, location, health_query, submit_button, history, state):
+    # Chatbot interaction
+    history, _ = chatbot(message, history)
+    
+    # Sentiment analysis
+    sentiment_response = analyze_sentiment(message)
+    
+    # Emotion detection
+    emotion_response = detect_emotion(message)
+    
+    # Health professional search and map display
+    route_info, map_html = get_health_professionals_and_map(location, health_query)
+    
+    # Generate suggestions based on the detected emotion
+    suggestions = generate_suggestions(emotion_response.split(': ')[1])
+    
+    # Create a DataFrame for displaying suggestions
+    suggestions_df = pd.DataFrame(suggestions)
+    
+    return history, sentiment_response, emotion_response, route_info, map_html, gr.DataFrame(suggestions_df, headers=["Title", "Subject", "Link"]), state
+
+# Gradio UI components
+message_input = gr.Textbox(lines=1, label="Message")
+location_input = gr.Textbox(value="Honolulu, HI", label="Current Location")
+health_query_input = gr.Textbox(value="doctor", label="Health Professional Query (e.g., doctor, psychiatrist, psychologist)")
+submit_button = gr.Button("Submit")  # Submit button
+
+# Updated chat history component with 'messages' type
+chat_history = gr.Chatbot(label="Well-Being Chat History", type='messages')
+
+# Outputs
+sentiment_output = gr.Textbox(label="Sentiment Analysis Result")
+emotion_output = gr.Textbox(label="Emotion Detection Result")
+route_info_output = gr.Textbox(label="Health Professionals Information")
+map_output = gr.HTML(label="Map with Health Professionals")
+suggestions_output = gr.DataFrame(label="Well-Being Suggestions", headers=["Title", "Subject", "Link"])
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=gradio_app, 
+    inputs=[message_input, location_input, health_query_input, submit_button, gr.State()],
+    outputs=[chat_history, sentiment_output, emotion_output, route_info_output, map_output, suggestions_output, gr.State()],
+    allow_flagging="never",
+    live=True,
+    title="Well-Being App: Support, Sentiment, Emotion Detection & Health Professional Search"
+)
+
+# Launch the Gradio interface
 iface.launch()