Update app.py

app.py

@@ -1,46 +1,52 @@
 import os
 import json
-import re
 import random
 import datetime
+import re
 from flask import Flask, request, jsonify, send_from_directory
 
-# Try to import huggingface pipeline; if unavailable we'll fallback to a keyword detector
+# Optional: Hugging Face emotion model if available (fallback to keyword heuristics)
 try:
     from transformers import pipeline
     HF_AVAILABLE = True
 except Exception:
     HF_AVAILABLE = False
 
-app = Flask(__name__)
+# OpenAI for generating supportive replies
+try:
+    import openai
+    OPENAI_AVAILABLE = True
+    openai.api_key = os.environ.get("OPENAI_API_KEY")
+    if not openai.api_key:
+        OPENAI_AVAILABLE = False
+except Exception:
+    OPENAI_AVAILABLE = False
 
-# ---------- Config ----------
-MEMORY_FILE = "chat_memory.json"
-MEMORY_KEEP_DAYS = 15
+app = Flask(__name__, static_folder=".", static_url_path="/")
 
-# Safe helplines map (country-code fallback handled via ipapi)
+# ----- CONFIG -----
+MEMORY_FILE = "session_memory.json"
+MEMORY_DAYS = 15
 HELPLINES = {
     "IN": "🇮🇳 India: AASRA Helpline 91-9820466726",
     "US": "🇺🇸 USA: Call or text 988 (Suicide & Crisis Lifeline)",
-    "GB": "🇬🇧 UK: Samaritans at 116 123",
-    "CA": "🇨🇦 Canada: Talk Suicide Canada at 1-833-456-4566",
+    "GB": "🇬🇧 UK: Samaritans 116 123",
+    "CA": "🇨🇦 Canada: Talk Suicide Canada 1-833-456-4566",
     "AU": "🇦🇺 Australia: Lifeline 13 11 14",
-    "DEFAULT": "If you are in crisis, please contact your local emergency number or visit https://findahelpline.com"
+    "DEFAULT": "If you are in crisis, please contact your local emergency number or use https://findahelpline.com"
 }
+CRISIS_TERMS = ["suicide","kill myself","end my life","i want to die","hurt myself","can't go on","cant go on","i don't want to live"]
 
-CRISIS_KEYWORDS = ["suicide","kill myself","end my life","want to die","hurt myself","cant go on","can't go on","i want to die"]
-
-# ---------- Try to load HF emotion model ----------
+# ----- Try load HF model (optional) -----
 emotion_model = None
 if HF_AVAILABLE:
     try:
-        # this may be large; if it fails we'll catch
         emotion_model = pipeline("text-classification", model="j-hartmann/emotion-english-distilroberta-base", top_k=5)
     except Exception:
         emotion_model = None
 
-# ---------- Memory helpers ----------
-def read_memory():
+# ----- Memory helpers -----
+def load_memory():
     if os.path.exists(MEMORY_FILE):
         try:
             with open(MEMORY_FILE, "r") as f:
@@ -49,44 +55,41 @@ def read_memory():
             data = {}
     else:
         data = {}
-    # prune old entries
-    cutoff = datetime.datetime.utcnow() - datetime.timedelta(days=MEMORY_KEEP_DAYS)
-    keep = {}
+    # prune by date
+    cutoff = datetime.datetime.utcnow() - datetime.timedelta(days=MEMORY_DAYS)
+    out = {}
     for k,v in data.items():
         try:
             t = datetime.datetime.fromisoformat(v.get("last_seen"))
             if t >= cutoff:
-                keep[k] = v
+                out[k] = v
         except Exception:
-            # keep if malformed time
-            keep[k] = v
-    return keep
+            out[k] = v
+    return out
 
-def write_memory(mem):
+def save_memory(mem):
     with open(MEMORY_FILE, "w") as f:
         json.dump(mem, f, indent=2)
 
-memory = read_memory()
+memory = load_memory()
 
-# ---------- Utilities ----------
-def extract_name(text:str):
-    # look for patterns: i'm X, i am X, my name is X
+# ----- small NLP helpers -----
+def extract_name(text):
+    # patterns: "I'm X", "I am X", "My name is X" or single capitalized word
     text = text.strip()
     patterns = [
-        r"^(?:i am|i'm|im|i’m)\s+([A-Z][a-z]+(?:\s[A-Z][a-z]+)?)",   # "I'm John", favor capitalization
-        r"my name is\s+([A-Z][a-z]+(?:\s[A-Z][a-z]+)?)",
-        r"^([A-Z][a-z]{1,20})$"  # single capitalized word
+        r"^(?:i am|i'm|im|i’m)\s+([A-Za-z][A-Za-z '-]{1,40})",
+        r"my name is\s+([A-Za-z][A-Za-z '-]{1,40})",
+        r"^([A-Z][a-z]{1,30})$"
     ]
     for p in patterns:
         m = re.search(p, text, flags=re.IGNORECASE)
         if m:
             name = m.group(1).strip()
-            # normalize capitalization
             return " ".join([w.capitalize() for w in name.split()])
     return None
 
-def extract_age(text:str):
-    # extract first integer that looks like an age between 8 and 120
+def extract_age(text):
     nums = re.findall(r"\b([1-9][0-9]?)\b", text)
     for n in nums:
         val = int(n)
@@ -94,225 +97,291 @@ def extract_age(text:str):
             return val
     return None
 
-def detect_crisis(text:str):
-    low = text.lower()
-    for kw in CRISIS_KEYWORDS:
-        if kw in low:
-            return True
-    return False
+def detect_crisis(text):
+    t = text.lower()
+    return any(term in t for term in CRISIS_TERMS)
 
-def get_country_from_ip(ip):
-    # Best-effort; if it fails return None
+def get_helpline_by_ip(remote_addr):
+    # best effort: call ipapi.co
     try:
         import requests
-        r = requests.get(f"https://ipapi.co/{ip}/json/", timeout=3)
+        ip = remote_addr if remote_addr and ":" not in remote_addr else ""
+        url = "https://ipapi.co/json/" if not ip else f"https://ipapi.co/{ip}/json/"
+        r = requests.get(url, timeout=2)
         if r.status_code == 200:
             data = r.json()
-            return data.get("country_code")
+            code = data.get("country_code", "").upper()
+            return HELPLINES.get(code, HELPLINES["DEFAULT"])
     except Exception:
         pass
-    return None
+    return HELPLINES["DEFAULT"]
 
-def emotion_from_text(text):
-    # Primary: use HF if available
+def classify_emotion(text):
+    # try HF model, fallback to keywords
     if emotion_model:
         try:
             out = emotion_model(text)
-            # out is list of dicts; take top label
-            if isinstance(out, list) and len(out)>0:
-                # out may be list of lists: ensure flatten
-                if isinstance(out[0], list):
-                    best = out[0][0]["label"]
+            if isinstance(out, list):
+                # pipeline may return list of lists or list of dicts
+                first = out[0]
+                if isinstance(first, list):
+                    label = first[0]["label"]
                 else:
-                    best = out[0]["label"]
-                return best.lower()
+                    label = first["label"]
+                return label.lower()
         except Exception:
             pass
-    # Fallback keyword mapping
+    # keyword fallback
     low = text.lower()
-    if any(w in low for w in ["happy","glad","great","good","joy","joyful","thank"]):
+    if any(w in low for w in ["happy","glad","joy","great","good","awesome"]):
         return "joy"
     if any(w in low for w in ["sad","down","depressed","unhappy","lonely","cry"]):
         return "sadness"
-    if any(w in low for w in ["angry","mad","furious","annoyed","irritat"]):
+    if any(w in low for w in ["angry","mad","furious","hate","annoy"]):
         return "anger"
-    if any(w in low for w in ["scared","afraid","anxious","panic","fear"]):
+    if any(w in low for w in ["scared","afraid","anxious","panic","worried"]):
         return "fear"
     if any(w in low for w in ["love","loving","cherish","fond"]):
         return "love"
     return "neutral"
 
-# Varied empathetic templates to avoid repetition
-EMP_OPENERS = [
-    "That sounds really hard — thank you for telling me.",
-    "I can hear how much that means to you.",
-    "Wow — that must have taken a lot to share. I’m here.",
-    "You’ve taken a brave step by saying that. I’m listening.",
-    "I’m with you — that sounds heavy and important.",
-    "I appreciate your honesty; I’m right here to listen.",
-    "That must have felt deeply upsetting. Tell me more if you want."
+# ----- Avoid repetitiveness helpers -----
+VARIED_ACKS = [
+    "That sounds really heavy — thank you for trusting me with that.",
+    "I can hear how much that matters to you.",
+    "You’ve shared something important. I’m here with you.",
+    "That must have taken courage to say. I’m listening."
 ]
-EMP_FOLLOWUPS = [
-    "Would you like to share more about what’s been going on?",
-    "How has that been affecting your day-to-day?",
-    "What helps you feel even a little bit better when that happens?",
-    "Would you prefer a calming exercise or some practical steps?",
-    "Do you want help breaking this down into smaller parts?"
+VARIED_FOLLOWUPS = [
+    "Would you like to tell me more about what’s been happening?",
+    "How has that been affecting your day-to-day life?",
+    "What usually helps you when you feel this way?",
+    "Would you like a calming exercise or practical next steps?"
 ]
-MOTIVATIONAL = [
-    "Even small steps are meaningful — you don’t have to do it all at once.",
-    "Rest is allowed. Healing isn’t a straight line.",
-    "You’ve come this far; that shows strength.",
-    "A single breath can sometimes soften what’s heavy."
+MOTIVATIONAL_SNIPPETS = [
+    "Even small steps count. You don't have to do it all at once.",
+    "It's okay to rest and take care of yourself.",
+    "You’ve handled so much already — that shows strength.",
+    "Breath by breath, you are moving forward."
 ]
 
-# ---------- Main chat route ----------
+# ----- OpenAI helper: build system prompt for mixed-mode personalities (Option C) -----
+def build_system_prompt(personality_choice, past_memory):
+    # personality_choice is an id like 'calm_male', etc.
+    # past_memory: dict with name, age, last_mood
+    base = (
+        "You are 'Serenity', a warm, compassionate emotional-support assistant. "
+        "Be supportive, curiosity-led, and avoid giving medical or legal advice. "
+        "Do not use the same short phrase repeatedly. Vary vocabulary and sentence structure. "
+        "Always be empathetic, concise when user is distressed, more chatty when user is okay. "
+        "When user shows crisis language, immediately offer helpline info and encourage contacting emergency services."
+    )
+
+    # personalities mapping
+    persona_map = {
+        "calm_male": "Use a calm male-tone voice: steady, grounding, gentle. Slightly formal but warm.",
+        "deep_male": "Use a deep baritone male-tone: slow, resonant, reassuring.",
+        "soothing_male": "Use a soothing male counselor-tone: mellow and kind.",
+        "gentle_female": "Use a gentle female-tone: tender, nurturing, caring.",
+        "feminine_female": "Use a feminine bright-tone: warm and encouraging.",
+        "deep_female": "Use a deeper female-tone: soulful and empathetic.",
+        "soothing_female": "Use a clear soothing female-tone: calm and steady.",
+        "neutral": "Use a neutral friendly-tone: balanced, soft, non-gendered."
+    }
+    persona = persona_map.get(personality_choice, persona_map["neutral"])
+
+    memory_note = ""
+    if past_memory:
+        nm = past_memory.get("name")
+        last = past_memory.get("last_mood")
+        if nm:
+            memory_note += f" The user is called {nm}."
+        if last:
+            memory_note += f" The user's recent mood was: {last}."
+
+    # Add few-shot style guidance for followups and variety
+    examples = (
+        "\nExamples of empathetic flow (do not repeat exact wording):\n"
+        "- User: 'I've been so down lately.' -> Assistant: 'I can hear how heavy that feels. Would you like to share what triggered it?' \n"
+        "- User: 'I can't sleep, I'm anxious' -> Assistant: 'That must be exhausting. Try breathing with me for a minute — would you like that?' \n"
+        "- User: 'How are you?' -> Assistant: Provide a short warm, slightly human reply and then re-focus on the user: e.g. 'I'm here and ready to listen — how are you feeling today?'\n"
+    )
+
+    return "\n".join([base, persona, memory_note, examples])
+
+# ----- Generate assistant reply via OpenAI (preferred) or friendly fallback -----
+def generate_assistant_reply(user_message, personality, session_memory):
+    name = session_memory.get("name", "friend")
+    age = session_memory.get("age")
+    last_mood = session_memory.get("last_mood")
+
+    # If OpenAI not configured, produce a careful local fallback using templates
+    if not OPENAI_AVAILABLE:
+        # we still use classification to vary replies
+        emo = classify_emotion(user_message)
+        if emo in ("sadness","fear","anger"):
+            reply = random.choice(VARIED_ACKS) + " " + random.choice(VARIED_FOLLOWUPS)
+        elif emo in ("joy","love"):
+            reply = f"That's wonderful, {name}! So glad to hear that. What made it bright for you?"
+        else:
+            if any(w in user_message.lower() for w in ("help","guidance","motivate","motivation","advice")):
+                reply = random.choice(MOTIVATIONAL_SNIPPETS)
+            else:
+                reply = random.choice(VARIED_ACKS)
+        return reply, emo
+
+    # Build system + user prompt for OpenAI
+    system_prompt = build_system_prompt(personality or "neutral", session_memory)
+    messages = [
+        {"role":"system", "content": system_prompt},
+        {"role":"user", "content": f"User (named {name if name else 'unknown'}) says: {user_message}"}
+    ]
+
+    try:
+        resp = openai.ChatCompletion.create(
+            model = os.environ.get("OPENAI_MODEL","gpt-4o-mini"),
+            messages = messages,
+            temperature = 0.8,
+            max_tokens = 512,
+            n = 1
+        )
+        text = resp.choices[0].message.content.strip()
+        # compute emotion via classifier
+        emo = classify_emotion(user_message)
+        # small safety: prevent repetitive single-line "I understand"
+        normalized = text.strip().lower()
+        if normalized in ("i understand", "i see", "okay", "i'm sorry to hear that"):
+            text = random.choice(VARIED_ACKS)
+        return text, emo
+    except Exception:
+        # fallback if OpenAI errors
+        emo = classify_emotion(user_message)
+        if emo in ("sadness","fear","anger"):
+            reply = random.choice(VARIED_ACKS) + " " + random.choice(VARIED_FOLLOWUPS)
+        elif emo in ("joy","love"):
+            reply = f"That's wonderful, {name}! Tell me more about that good thing."
+        else:
+            reply = random.choice(VARIED_ACKS)
+        return reply, emo
+
+# ----- Routes -----
+@app.route("/")
+def index():
+    return send_from_directory(".", "index.html")
+
 @app.route("/chat", methods=["POST"])
 def chat():
     global memory
-    payload = request.get_json() or {}
-    session = payload.get("session") or request.remote_addr or "default"
-    message = (payload.get("message") or "").strip()
-    # flag used by frontend to ask the server for initial greeting only once
-    init_flag = payload.get("init", False)
+    data = request.get_json() or {}
+    session = data.get("session") or request.remote_addr or "default"
+    message = (data.get("message") or "").strip()
+    personality = data.get("personality") or data.get("voice_profile") or "neutral"
+    init_flag = data.get("init", False)
 
-    # ensure memory slot for session
+    # ensure session slot
     slot = memory.get(session, {})
-    now_iso = datetime.datetime.utcnow().isoformat()
+    now = datetime.datetime.utcnow().isoformat()
 
-    # On init: if no name known, return friendly opener (but only if init true)
+    # If init flag, return initial greeting or follow-up if we have memory
     if init_flag:
         if not slot.get("name"):
-            return jsonify({"reply":"Hey there! What’s your name?", "emotion":"calm"})
+            slot.setdefault("last_seen", now)
+            memory[session] = slot
+            save_memory(memory)
+            return jsonify({"reply":"Hey there — I’m Serenity. What’s your name?", "emotion":"calm"})
         else:
-            # If name present, maybe check recent mood
             last_mood = slot.get("last_mood")
             last_seen = slot.get("last_seen")
-            if last_mood in ("sadness","anger","fear") and last_seen:
-                try:
-                    last_t = datetime.datetime.fromisoformat(last_seen)
-                    if (datetime.datetime.utcnow() - last_t).days <= MEMORY_KEEP_DAYS:
-                        return jsonify({"reply":f"Hey {slot.get('name')}, you seemed a bit down last time — how are you feeling now?", "emotion":"warm"})
-                except Exception:
-                    pass
-            return jsonify({"reply":f"Hey {slot.get('name')} — I’m here. What’s on your mind?", "emotion":"calm"})
-
-    # If no text provided, ask user to say something
+            try:
+                if last_mood in ("sadness","fear","anger") and last_seen:
+                    t = datetime.datetime.fromisoformat(last_seen)
+                    if (datetime.datetime.utcnow() - t).days <= MEMORY_DAYS:
+                        return jsonify({"reply":f"Hey {slot.get('name')}, I remember you were having a tough time last time. How are you today?", "emotion":"warm"})
+            except Exception:
+                pass
+            return jsonify({"reply":f"Welcome back {slot.get('name')} — I'm here for you. What's on your mind?", "emotion":"calm"})
+
+    # If message empty
     if not message:
-        return jsonify({"reply":"I’m listening — when you’re ready, share anything that’s on your mind.", "emotion":"neutral"})
-
-    # If session has awaiting flag (expecting name or age), handle it
-    awaiting = slot.get("awaiting")  # could be "name" or "age" or None
+        return jsonify({"reply":"I’m listening whenever you’re ready — tell me what’s on your mind.", "emotion":"neutral"})
 
-    # Try to extract name if message looks like a name
+    # If awaiting name or age from previous flow
+    awaiting = slot.get("awaiting")
     if not slot.get("name") and not awaiting:
-        # If message contains natural name phrases, extract
-        extracted = extract_name(message)
-        if extracted:
-            slot["name"] = extracted
-            slot["last_seen"] = now_iso
-            slot["last_mood"] = emotion_from_text(message)
+        # Try to extract name
+        name_extracted = extract_name(message)
+        if name_extracted:
+            slot["name"] = name_extracted
+            slot["awaiting"] = "age"
+            slot["last_seen"] = now
             memory[session] = slot
-            write_memory(memory)
-            # ask age next
-            slot["awaiting"]="age"
-            memory[session]=slot
-            write_memory(memory)
-            return jsonify({"reply":f"Lovely to meet you, {extracted}! How old are you?", "emotion":"curious"})
+            save_memory(memory)
+            return jsonify({"reply":f"Lovely to meet you, {name_extracted}! How old are you?", "emotion":"curious"})
         else:
-            # If not extractable, ask name explicitly and set awaiting flag
-            slot["awaiting"]="name"
-            slot["last_seen"] = now_iso
-            memory[session]=slot
-            write_memory(memory)
-            return jsonify({"reply":"Hey there! What’s your name?", "emotion":"calm"})
+            slot["awaiting"] = "name"
+            slot["last_seen"] = now
+            memory[session] = slot
+            save_memory(memory)
+            return jsonify({"reply":"Hey — what should I call you? What's your name?", "emotion":"calm"})
 
-    # If we are expecting name
     if awaiting == "name":
-        # accept entire message as name (sanitize)
         name_guess = extract_name(message) or message.split()[0].capitalize()
         slot["name"] = name_guess
         slot.pop("awaiting", None)
-        slot["last_seen"]=now_iso
+        slot["last_seen"] = now
+        slot["awaiting"] = "age"
         memory[session]=slot
-        write_memory(memory)
-        # ask age
-        slot["awaiting"]="age"
-        memory[session]=slot
-        write_memory(memory)
+        save_memory(memory)
         return jsonify({"reply":f"Nice to meet you, {name_guess}! How old are you?", "emotion":"curious"})
 
-    # If we are expecting age
     if awaiting == "age":
-        age_val = extract_age(message)
-        if age_val:
-            slot["age"]=age_val
+        age_guess = extract_age(message)
+        if age_guess:
+            slot["age"] = age_guess
             slot.pop("awaiting", None)
-            slot["last_seen"]=now_iso
+            slot["last_seen"] = now
             memory[session]=slot
-            write_memory(memory)
-            return jsonify({"reply":f"Thanks — got that. {slot.get('name')}, how are you feeling today?", "emotion":"curious"})
+            save_memory(memory)
+            return jsonify({"reply":f"Thanks — got it. {slot.get('name')}, how have you been feeling lately?", "emotion":"curious"})
         else:
-            # If message didn't include a clear age, ask again
-            return jsonify({"reply":"Could you tell me your age as a number (for example: 20)?", "emotion":"neutral"})
-
-    # At this point, name and age are present (or already set). Proceed to normal chat.
+            return jsonify({"reply":"Could you tell me your age as a number (for example: 24)?", "emotion":"neutral"})
 
-    # If message indicates crisis, handle immediately
+    # Crisis detection
     if detect_crisis(message):
-        # try to detect country from IP
-        ip = request.remote_addr or ""
-        country_code = get_country_from_ip(ip) or "DEFAULT"
-        helpline = HELPLINES.get(country_code, HELPLINES["DEFAULT"])
-        reply = (f"I’m really concerned about how you’re feeling. You are not alone. "
-                 f"Please consider reaching out to emergency services or a helpline nearby: {helpline}")
-        # don't overwrite memory last_mood to crisis; set a flag
-        slot["last_seen"]=now_iso
-        slot["last_mood"]="crisis"
-        memory[session]=slot
-        write_memory(memory)
+        helpline = get_helpline_by_ip(request.remote_addr)
+        slot["last_mood"] = "crisis"
+        slot["last_seen"] = now
+        memory[session] = slot
+        save_memory(memory)
+        reply = (f"I’m really concerned about how you're feeling right now. You are not alone. "
+                 f"Please consider contacting emergency services or a helpline: {helpline}")
         return jsonify({"reply":reply, "emotion":"crisis"})
 
-    # Normal chat: compute emotion
-    emotion = emotion_from_text(message)
-
-    # generate supportive response (use varied templates and avoid repetition)
-    base = ""
-    # Introspective responses for heavy emotions
-    if emotion in ("sadness","fear","anger"):
-        base = random.choice(EMP_OPENERS) + " " + random.choice(EMP_FOLLOWUPS)
-    elif emotion in ("joy","love"):
-        base = f"That’s lovely — I’m really glad to hear that, {slot.get('name','friend')}!"
-    else:
-        # neutral / other
-        if any(word in message.lower() for word in ("help","guidance","motivate","motivation","inspire")):
-            base = random.choice(MOTIVATIONAL)
-        else:
-            base = random.choice(EMP_OPENERS)
-
-    # occasionally add a short motivational bit when appropriate
-    if emotion in ("sadness","fear") and random.random() < 0.5:
-        base = base + " " + random.choice(MOTIVATIONAL)
-
-    # update memory
+    # Generate reply via OpenAI or fallback templates
+    reply_text, emotion = generate_assistant_reply(message, personality, slot)
+    # store memory
     slot["last_mood"] = emotion
-    slot["last_seen"] = now_iso
-    if not slot.get("name"):
-        slot["name"] = "friend"
+    slot["last_seen"] = now
+    # keep a short history
+    hist = slot.get("history", [])
+    hist.append({"time": now, "in": message, "out": reply_text, "emotion": emotion})
+    # keep only last 20 messages
+    slot["history"] = hist[-20:]
     memory[session] = slot
-    write_memory(memory)
+    save_memory(memory)
 
-    # Enrich to avoid very short repetitive replies
-    # If the base is very short or repeated wordy, diversify
-    reply = base
+    return jsonify({"reply": reply_text, "emotion": emotion})
 
-    return jsonify({"reply": reply, "emotion": emotion})
-
-# Serve frontend
-@app.route("/")
-def index():
-    return send_from_directory(".", "index.html")
+# optional endpoint to clear a session (new chat)
+@app.route("/reset_session", methods=["POST"])
+def reset_session():
+    data = request.get_json() or {}
+    session = data.get("session")
+    if session and session in memory:
+        memory.pop(session, None)
+        save_memory(memory)
+    return jsonify({"ok": True})
 
 if __name__ == "__main__":
-    # On Spaces, they auto-run; but for standalone testing:
-    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))
+    port = int(os.environ.get("PORT", 7860))
+    app.run(host="0.0.0.0", port=port)