Update it.

app.py

@@ -1,120 +1,318 @@
+import os
+import json
+import re
+import random
+import datetime
 from flask import Flask, request, jsonify, send_from_directory
-from transformers import pipeline
-import json, os, datetime
+
+# Try to import huggingface pipeline; if unavailable we'll fallback to a keyword detector
+try:
+    from transformers import pipeline
+    HF_AVAILABLE = True
+except Exception:
+    HF_AVAILABLE = False
 
 app = Flask(__name__)
 
-# load emotion model
-emotion_analyzer = pipeline("text-classification",
-                             model="j-hartmann/emotion-english-distilroberta-base",
-                             top_k=None)
+# ---------- Config ----------
+MEMORY_FILE = "chat_memory.json"
+MEMORY_KEEP_DAYS = 15
+
+# Safe helplines map (country-code fallback handled via ipapi)
+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",
+    "AU": "🇦🇺 Australia: Lifeline 13 11 14",
+    "DEFAULT": "If you are in crisis, please contact your local emergency number or visit https://findahelpline.com"
+}
 
-DATA_FILE = "user_data.json"
+CRISIS_KEYWORDS = ["suicide","kill myself","end my life","want to die","hurt myself","cant go on","can't go on","i want to die"]
 
-def load_user_data():
-    if os.path.exists(DATA_FILE):
-        with open(DATA_FILE, "r") as f:
-            return json.load(f)
-    return {}
+# ---------- Try to load HF emotion model ----------
+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():
+    if os.path.exists(MEMORY_FILE):
+        try:
+            with open(MEMORY_FILE, "r") as f:
+                data = json.load(f)
+        except Exception:
+            data = {}
+    else:
+        data = {}
+    # prune old entries
+    cutoff = datetime.datetime.utcnow() - datetime.timedelta(days=MEMORY_KEEP_DAYS)
+    keep = {}
+    for k,v in data.items():
+        try:
+            t = datetime.datetime.fromisoformat(v.get("last_seen"))
+            if t >= cutoff:
+                keep[k] = v
+        except Exception:
+            # keep if malformed time
+            keep[k] = v
+    return keep
 
-def save_user_data(data):
-    with open(DATA_FILE, "w") as f:
-        json.dump(data, f, indent=2)
+def write_memory(mem):
+    with open(MEMORY_FILE, "w") as f:
+        json.dump(mem, f, indent=2)
+
+memory = read_memory()
+
+# ---------- Utilities ----------
+def extract_name(text:str):
+    # look for patterns: i'm X, i am X, my name is X
+    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
+    ]
+    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 detect_emotion(text):
-    result = emotion_analyzer(text)[0]
-    scores = {r["label"]: r["score"] for r in result}
-    return max(scores, key=scores.get)
+def extract_age(text:str):
+    # extract first integer that looks like an age between 8 and 120
+    nums = re.findall(r"\b([1-9][0-9]?)\b", text)
+    for n in nums:
+        val = int(n)
+        if 8 <= val <= 120:
+            return val
+    return None
 
-def crisis_check(text):
-    crisis_keywords = ["end my life", "kill myself", "suicide", "hurt myself"]
-    for word in crisis_keywords:
-        if word in text.lower():
+def detect_crisis(text:str):
+    low = text.lower()
+    for kw in CRISIS_KEYWORDS:
+        if kw in low:
             return True
     return False
 
+def get_country_from_ip(ip):
+    # Best-effort; if it fails return None
+    try:
+        import requests
+        r = requests.get(f"https://ipapi.co/{ip}/json/", timeout=3)
+        if r.status_code == 200:
+            data = r.json()
+            return data.get("country_code")
+    except Exception:
+        pass
+    return None
+
+def emotion_from_text(text):
+    # Primary: use HF if available
+    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"]
+                else:
+                    best = out[0]["label"]
+                return best.lower()
+        except Exception:
+            pass
+    # Fallback keyword mapping
+    low = text.lower()
+    if any(w in low for w in ["happy","glad","great","good","joy","joyful","thank"]):
+        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"]):
+        return "anger"
+    if any(w in low for w in ["scared","afraid","anxious","panic","fear"]):
+        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."
+]
+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?"
+]
+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."
+]
+
+# ---------- Main chat route ----------
 @app.route("/chat", methods=["POST"])
 def chat():
-    data = request.get_json()
-    user_message = data.get("message", "")
-    user_info = load_user_data()
-    user_name = user_info.get("name", "friend")
-    user_age = user_info.get("age", None)
-    emotion = detect_emotion(user_message)
-
-    # save mood history
-    now = datetime.datetime.now().strftime("%Y-%m-%d")
-    user_info["last_mood"] = emotion
-    user_info["last_seen"] = now
-    save_user_data(user_info)
-
-    # crisis check
-    if crisis_check(user_message):
-        return jsonify({
-            "reply": f"{user_name}, you matter. You're not alone. If you’re in danger, please reach out to your local emergency helpline or someone you trust immediately ❤️",
-            "emotion": "crisis"
-        })
-
-    empathy_responses = [
-        "That sounds tough, but I’m here for you.",
-        "I can sense how that feels. Tell me more, if you want.",
-        "That must be hard, but you’re doing better than you think.",
-        "I appreciate you sharing this with me.",
-        "Sometimes words aren’t enough, but I’m listening fully.",
-        "You’ve been strong for so long — it’s okay to let go here.",
-        "I hear you, truly. You’re safe here."
-    ]
+    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)
 
-    supportive_followups = [
-        "Would you like to talk more about what’s been on your mind?",
-        "Sometimes sharing even small details helps a little. Want to try?",
-        "Would you like something calming, or maybe a bit of motivation?"
-    ]
+    # ensure memory slot for session
+    slot = memory.get(session, {})
+    now_iso = datetime.datetime.utcnow().isoformat()
 
-    motivational_quotes = [
-        "Every sunrise brings a new chance to begin again 🌅",
-        "Even the darkest nights end with the light of dawn.",
-        "You’ve made it through 100% of your hardest days so far 💪",
-        "Storms make trees take deeper roots.",
-        "You are allowed to rest, not to quit."
-    ]
+    # On init: if no name known, return friendly opener (but only if init true)
+    if init_flag:
+        if not slot.get("name"):
+            return jsonify({"reply":"Hey there! 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"})
 
-    import random
-    reply = ""
-
-    if "name" not in user_info or "age" not in user_info:
-        if "name" not in user_info:
-            reply = "Hey there! What’s your name?"
-            user_info["awaiting"] = "name"
-        elif "age" not in user_info:
-            reply = f"Nice to meet you, {user_name}! How old are you?"
-            user_info["awaiting"] = "age"
-        save_user_data(user_info)
-    elif user_info.get("awaiting") == "name":
-        user_info["name"] = user_message.strip().split()[0]
-        reply = f"Lovely to meet you, {user_info['name']}! How old are you?"
-        user_info["awaiting"] = "age"
-        save_user_data(user_info)
-    elif user_info.get("awaiting") == "age":
-        user_info["age"] = user_message.strip().split()[0]
-        reply = f"Got it! So {user_info['age']} it is. How are you feeling today?"
-        user_info.pop("awaiting", None)
-        save_user_data(user_info)
-    elif "guidance" in user_message.lower() or "motivation" in user_message.lower():
-        reply = random.choice(motivational_quotes)
+    # If no text provided, ask user to say something
+    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
+
+    # Try to extract name if message looks like a name
+    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)
+            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"})
+        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"})
+
+    # 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
+        memory[session]=slot
+        write_memory(memory)
+        # ask age
+        slot["awaiting"]="age"
+        memory[session]=slot
+        write_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
+            slot.pop("awaiting", None)
+            slot["last_seen"]=now_iso
+            memory[session]=slot
+            write_memory(memory)
+            return jsonify({"reply":f"Thanks — got that. {slot.get('name')}, how are you feeling today?", "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.
+
+    # If message indicates crisis, handle immediately
+    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)
+        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:
-        if emotion in ["sadness", "fear", "anger"]:
-            reply = random.choice(empathy_responses) + " " + random.choice(supportive_followups)
-        elif emotion in ["joy", "love"]:
-            reply = f"That’s wonderful, {user_name}! I’m so glad to hear it 🌟"
+        # neutral / other
+        if any(word in message.lower() for word in ("help","guidance","motivate","motivation","inspire")):
+            base = random.choice(MOTIVATIONAL)
         else:
-            reply = random.choice(motivational_quotes)
+            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
+    slot["last_mood"] = emotion
+    slot["last_seen"] = now_iso
+    if not slot.get("name"):
+        slot["name"] = "friend"
+    memory[session] = slot
+    write_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, "emotion": emotion})
 
+# Serve frontend
 @app.route("/")
 def index():
     return send_from_directory(".", "index.html")
 
 if __name__ == "__main__":
-    app.run(host="0.0.0.0", port=7860)
+    # On Spaces, they auto-run; but for standalone testing:
+    app.run(host="0.0.0.0", port=int(os.environ.get("PORT", 7860)))