shbdvbs

ChatBot/rules/safety.py

@@ -1,38 +1,63 @@
-# safety.py
-
 import re
-import os
-import json
-from dotenv import load_dotenv
-from groq import Groq
-
-load_dotenv()
-
-client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-MODEL = "llama-3.1-8b-instant"
+from transformers import pipeline
 
 PUNCT_RE = re.compile(r"[^\w\s']")
 SPACE_RE = re.compile(r"\s+")
 
+
 def normalize(text: str) -> str:
+
     text = text.lower()
+
+    # normalize unicode apostrophes
     text = text.replace("’", "'")
+
+    # normalize common contractions
     text = text.replace("dont", "don't")
     text = text.replace("cant", "can't")
     text = text.replace("wont", "won't")
+
     text = PUNCT_RE.sub(" ", text)
     text = SPACE_RE.sub(" ", text).strip()
+
     return text
 
+
+# -------------------------
+# Lazy-loaded singleton
+# -------------------------
+_model = None
+
+
+def get_model():
+
+    global _model
+
+    if _model is None:
+
+        _model = pipeline(
+            "text-classification",
+            model="wcyat/distilbert-suicide-detection-hk"
+        )
+
+    return _model
+
+
 # -------------------------
 # Hard safety overrides
 # -------------------------
 HIGH_RISK_PATTERNS = [
+
+    # explicit intent
     r"\bi will kill myself\b",
     r"\bi am going to kill myself\b",
     r"\bend my life\b",
+
+    # method seeking
     r"\bhow to commit suicide\b",
     r"\bhow to kill myself\b",
+
+    # passive suicidal ideation
     r"\bi don't want to live anymore\b",
     r"\bi want to die\b",
     r"\bi wish i was dead\b",
@@ -41,6 +66,7 @@ HIGH_RISK_PATTERNS = [
     r"\bi can't go on\b",
 ]
 
+
 NEGATIONS = [
     "not suicidal",
     "i am not suicidal",
@@ -49,7 +75,9 @@ NEGATIONS = [
     "i don't want to kill myself",
 ]
 
+
 RECOVERY_PATTERNS = [
+
     r"\bi talked to a professional\b",
     r"\bi spoke to a therapist\b",
     r"\bi got help\b",
@@ -60,268 +88,91 @@ RECOVERY_PATTERNS = [
     r"\bi reached out\b",
 ]
 
-HIGH_RISK_RE = [re.compile(p) for p in HIGH_RISK_PATTERNS]
-RECOVERY_RE = [re.compile(p) for p in RECOVERY_PATTERNS]
+
+HIGH_RISK_RE = [
+    re.compile(p)
+    for p in HIGH_RISK_PATTERNS
+]
+
+
+RECOVERY_RE = [
+    re.compile(p)
+    for p in RECOVERY_PATTERNS
+]
+
 
 # -------------------------
 # Main detector
 # -------------------------
 def check_critical(text: str) -> bool:
+
     if not text or len(text.strip()) < 5:
         return False
 
     t = normalize(text)
 
-    # 1. Recovery override
+    # -------------------------
+    # Recovery override
+    # -------------------------
     for pattern in RECOVERY_RE:
+
         if pattern.search(t):
+
             print("Recovery signal detected")
+
             return False
 
-    # 2. Negation override
+    # -------------------------
+    # Negation override
+    # -------------------------
     for neg in NEGATIONS:
+
         if neg in t:
+
             print("Negation detected")
+
             return False
 
-    # 3. Explicit hard override
+    # -------------------------
+    # Explicit hard override
+    # -------------------------
     for pattern in HIGH_RISK_RE:
+
         if pattern.search(t):
+
             print("Critical detected via regex")
+            print("Matched pattern:", pattern.pattern)
+
             return True
 
-    # 4. Advanced Clinical Safety Screening via Groq
-    system_prompt = """
-    You are an elite safety screening system, strictly modeled after fine-tuned DistilBERT text classification pipelines for self-harm monitoring.
-    Your absolute priority is to draw a sharp line between general depressive/exhausted low moods (SAFE) and acute self-harm crises (CRITICAL).
-
-    ### STRICT DIFFERENTIAL BOUNDARY RULES:
-    - "LABEL_0" (SAFE): General depression, crying, feeling deeply sad, loneliness, situational stress, heavy academic/work burnout, fatigue, expressing "I have no energy", or venting about a miserable day WITHOUT active self-harm intent. Even if the text is overwhelmingly negative or sorrowful, if there is no active self-harm or suicidal structure, it MUST be classified as LABEL_0.
-    - "LABEL_1" (CRITICAL): Active or acute suicidal ideation, explicit statements of intent to self-harm, discussing methods, execution planning, final farewell gestures, or immediate danger to their own life.
-
-    ### Scoring Calibration
-    The downstream app relies on a strict threshold where score >= 0.97 for LABEL_1 triggers an emergency crisis protocol. 
-    - Do NOT let deep sadness or heavy venting pull the model into an ambiguous high-score LABEL_1.
-    - If a user is expressing standard low mood or intense fatigue without clear self-harm indications, you must aggressively classify it as LABEL_0 with a high score.
-
-    ### Expected JSON Output Format
-    {
-      "clinical_distinction": {
-        "contains_active_self_harm_or_suicidal_framework": false,
-        "is_permissible_emotional_venting_or_depression": true
-      },
-      "label": "LABEL_0",
-      "score": 0.99
-    }
-    """
+    # -------------------------
+    # Transformer inference
+    # -------------------------
+    model = get_model()
 
     try:
-        response = client.chat.completions.create(
-            model=MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": text[:2000]}
-            ],
-            temperature=0.0, # Kept at 0.0 for objective, rigid logical evaluation
-            response_format={"type": "json_object"}
-        )
 
-        result = json.loads(response.choices[0].message.content)
-        
-        label = result.get("label", "LABEL_0")
-        score = float(result.get("score", 0.0))
-        
-        print(f"Groq Safety Pipeline -> Label: {label}, Score: {score:.4f}")
+        result = model(text[:512])[0]
+
+        print("Safety model result:", result)
 
     except Exception as e:
-        print("Groq Safety API Error:", e)
+
+        print("Safety model error:", e)
+
         return False
 
-    # 5. Semantic self-harm detection threshold
+    label = result["label"]
+    score = float(result["score"])
+
+    # -------------------------
+    # Semantic self-harm detection
+    # -------------------------
     decision = (
         label == "LABEL_1"
         and score >= 0.97 
     )
 
-    print("Final Critical Decision:", decision)
-    return decision
-
-
-# import re
-# from transformers import pipeline
-
-# PUNCT_RE = re.compile(r"[^\w\s']")
-# SPACE_RE = re.compile(r"\s+")
-
-
-# def normalize(text: str) -> str:
-
-#     text = text.lower()
-
-#     # normalize unicode apostrophes
-#     text = text.replace("’", "'")
-
-#     # normalize common contractions
-#     text = text.replace("dont", "don't")
-#     text = text.replace("cant", "can't")
-#     text = text.replace("wont", "won't")
-
-#     text = PUNCT_RE.sub(" ", text)
-#     text = SPACE_RE.sub(" ", text).strip()
-
-#     return text
-
-
-# # -------------------------
-# # Lazy-loaded singleton
-# # -------------------------
-# _model = None
-
-
-# def get_model():
-
-#     global _model
-
-#     if _model is None:
-
-#         _model = pipeline(
-#             "text-classification",
-#             model="wcyat/distilbert-suicide-detection-hk"
-#         )
-
-#     return _model
-
-
-# # -------------------------
-# # Hard safety overrides
-# # -------------------------
-# HIGH_RISK_PATTERNS = [
-
-#     # explicit intent
-#     r"\bi will kill myself\b",
-#     r"\bi am going to kill myself\b",
-#     r"\bend my life\b",
-
-#     # method seeking
-#     r"\bhow to commit suicide\b",
-#     r"\bhow to kill myself\b",
-
-#     # passive suicidal ideation
-#     r"\bi don't want to live anymore\b",
-#     r"\bi want to die\b",
-#     r"\bi wish i was dead\b",
-#     r"\bbetter off dead\b",
-#     r"\bno reason to live\b",
-#     r"\bi can't go on\b",
-# ]
-
-
-# NEGATIONS = [
-#     "not suicidal",
-#     "i am not suicidal",
-#     "i don't want to die",
-#     "i do not want to die",
-#     "i don't want to kill myself",
-# ]
-
-
-# RECOVERY_PATTERNS = [
-
-#     r"\bi talked to a professional\b",
-#     r"\bi spoke to a therapist\b",
-#     r"\bi got help\b",
-#     r"\bit helped\b",
-#     r"\bi feel better\b",
-#     r"\bi am feeling better\b",
-#     r"\bthings are improving\b",
-#     r"\bi reached out\b",
-# ]
-
-
-# HIGH_RISK_RE = [
-#     re.compile(p)
-#     for p in HIGH_RISK_PATTERNS
-# ]
-
-
-# RECOVERY_RE = [
-#     re.compile(p)
-#     for p in RECOVERY_PATTERNS
-# ]
-
-
-# # -------------------------
-# # Main detector
-# # -------------------------
-# def check_critical(text: str) -> bool:
-
-#     if not text or len(text.strip()) < 5:
-#         return False
-
-#     t = normalize(text)
-
-#     # -------------------------
-#     # Recovery override
-#     # -------------------------
-#     for pattern in RECOVERY_RE:
-
-#         if pattern.search(t):
-
-#             print("Recovery signal detected")
-
-#             return False
-
-#     # -------------------------
-#     # Negation override
-#     # -------------------------
-#     for neg in NEGATIONS:
-
-#         if neg in t:
-
-#             print("Negation detected")
-
-#             return False
-
-#     # -------------------------
-#     # Explicit hard override
-#     # -------------------------
-#     for pattern in HIGH_RISK_RE:
-
-#         if pattern.search(t):
-
-#             print("Critical detected via regex")
-#             print("Matched pattern:", pattern.pattern)
-
-#             return True
-
-#     # -------------------------
-#     # Transformer inference
-#     # -------------------------
-#     model = get_model()
-
-#     try:
-
-#         result = model(text[:512])[0]
-
-#         print("Safety model result:", result)
-
-#     except Exception as e:
-
-#         print("Safety model error:", e)
-
-#         return False
-
-#     label = result["label"]
-#     score = float(result["score"])
-
-#     # -------------------------
-#     # Semantic self-harm detection
-#     # -------------------------
-#     decision = (
-#         label == "LABEL_1"
-#         and score >= 0.97 
-#     )
-
-#     print("Critical decision:", decision)
+    print("Critical decision:", decision)
 
-#     return decision
+    return decision

Dockerfile

@@ -0,0 +1,17 @@
+FROM python:3.10-slim
+
+# Set working directory
+WORKDIR /app
+
+# Install dependencies
+COPY requirements.txt .
+RUN pip install --no-cache-dir -r requirements.txt gunicorn
+
+# Copy project files
+COPY . .
+
+# Expose port (Hugging Face uses 7860 by default)
+EXPOSE 7860
+
+# Start the application
+CMD ["gunicorn", "--bind", "0.0.0.0:7860", "mental_health.wsgi:application"]

core/sentiment.py

@@ -1,179 +1,102 @@
-import os
-import json
-from dotenv import load_dotenv
-from groq import Groq
+# sentiment.py
 
-load_dotenv()
+from transformers import pipeline
 
-client = Groq(api_key=os.getenv("GROQ_API_KEY"))
-MODEL = "llama-3.1-8b-instant"
+# Lazy-loaded singleton
 
-def analyze_text(text: str):
-    if not text or not text.strip():
-        return {"label": "NEUTRAL", "score": 0.5, "mood": "neutral"}
-
-    # ADVANCED CHAIN-OF-THOUGHT PROMPT
-    system_prompt = """
-    You are an elite psychological sentiment analyzer, modeled after DistilRoBERTa emotion classifiers.
-    Analyze the user's text and return strictly a JSON object.
-
-    ### Step 1: Ekman Emotion Analysis
-    First, evaluate the text across these 7 core emotions (must add up to 1.0):
-    - "joy", "sadness", "anger", "fear", "surprise", "disgust", "neutral".
-
-    ### Step 2: Mapping to Internal State
-    Based on the dominant Ekman emotions, map the result to EXACTLY ONE of these target moods:
-    - "great" (High Joy / Positive Surprise) -> Label: POSITIVE
-    - "good" (Mild Joy / Contentment) -> Label: POSITIVE
-    - "neutral" (High Neutral) -> Label: NEUTRAL
-    - "stressed" (High Fear / Anxiety) -> Label: NEGATIVE
-    - "low" (High Sadness / Disappointment) -> Label: NEGATIVE
-    - "overwhelmed" (High Anger / Disgust / Overload) -> Label: NEGATIVE
-
-    ### Expected JSON Output Format
-    {
-      "ekman_scores": {
-        "joy": 0.0,
-        "sadness": 0.7,
-        "anger": 0.1,
-        "fear": 0.0,
-        "surprise": 0.0,
-        "disgust": 0.0,
-        "neutral": 0.2
-      },
-      "label": "NEGATIVE",
-      "mood": "low",
-      "score": 0.75
-    }
-    """
-
-    try:
-        response = client.chat.completions.create(
-            model=MODEL,
-            messages=[
-                {"role": "system", "content": system_prompt},
-                {"role": "user", "content": text[:2000]} 
-            ],
-            temperature=0.1, 
-            response_format={"type": "json_object"} 
+_model = None
+
+def get_model():
+    global _model
+    if _model is None:
+        _model = pipeline(
+            "text-classification",
+            model="j-hartmann/emotion-english-distilroberta-base",
+            return_all_scores=True
         )
+    return _model
+
+
+# Chunking (still needed for long text)
+def split_text(text, max_len=400):
+    sentences = text.split(". ")
+    chunks, current = [], ""
+
+    for s in sentences:
+        if len(current) + len(s) < max_len:
+            current += s + ". "
+        else:
+            chunks.append(current.strip())
+            current = s + ". "
+
+    if current:
+        chunks.append(current.strip())
 
-        result = json.loads(response.choices[0].message.content)
-        
-        # We extract your specific keys, ignoring the ekman_scores which were just used for LLM reasoning
-        return {
-            "label": result.get("label", "NEUTRAL"),
-            "score": float(result.get("score", 0.5)),
-            "mood": result.get("mood", "neutral")
-        }
-
-    except Exception as e:
-        print("Groq Sentiment API Error:", e)
-        return {
-            "label": "NEUTRAL",
-            "score": 0.5,
-            "mood": "neutral"
-        }
-
-# # sentiment.py
-
-# from transformers import pipeline
-
-# # Lazy-loaded singleton
-
-# _model = None
-
-# def get_model():
-#     global _model
-#     if _model is None:
-#         _model = pipeline(
-#             "text-classification",
-#             model="j-hartmann/emotion-english-distilroberta-base",
-#             return_all_scores=True
-#         )
-#     return _model
-
-
-# # Chunking (still needed for long text)
-# def split_text(text, max_len=400):
-#     sentences = text.split(". ")
-#     chunks, current = [], ""
-
-#     for s in sentences:
-#         if len(current) + len(s) < max_len:
-#             current += s + ". "
-#         else:
-#             chunks.append(current.strip())
-#             current = s + ". "
-
-#     if current:
-#         chunks.append(current.strip())
-
-#     return chunks
-
-
-
-# # Emotion → your mood mapping
-# def map_emotion_to_mood(emotion: str):
-#     if emotion == "joy":
-#         return "good"
-#     elif emotion == "sadness":
-#         return "low"
-#     elif emotion == "anger":
-#         return "overwhelmed"
-#     elif emotion == "fear":
-#         return "stressed"
-#     elif emotion == "neutral":
-#         return "neutral"
-#     else:
-#         return "neutral"
-
-
-# def analyze_text(text: str):
-#     model = get_model()
-#     chunks = split_text(text)
-
-#     aggregated = {}
-
-#     for chunk in chunks:
-#         try:
-#             outputs = model(chunk[:512])
-#         except Exception:
-#             return {
-#                 "label": "NEUTRAL",
-#                 "score": 0.5,
-#                 "mood": "neutral"
-#             }
-
-#         # Normalize output
-#         if isinstance(outputs[0], list):
-#             results = outputs[0]  # return_all_scores=True case
-#         else:
-#             results = outputs     # single prediction case
-
-#         for r in results:
-#             if isinstance(r, dict):
-#                 label = r["label"]
-#                 score = r["score"]
-#             else:
-#                 # fallback if model returns string label
-#                 label = r
-#                 score = 1.0
-
-#             aggregated[label] = aggregated.get(label, 0) + score
-
-#     # average scores
-#     for k in aggregated:
-#         aggregated[k] /= len(chunks)
-
-#     # pick best emotion
-#     best_emotion = max(aggregated, key=aggregated.get)
-#     best_score = aggregated[best_emotion]
-
-#     mood = map_emotion_to_mood(best_emotion)
-
-#     return {
-#         "label": "POSITIVE" if mood in ["good"] else "NEGATIVE",
-#         "score": float(best_score),
-#         "mood": mood
-#     }
+    return chunks
+
+
+
+# Emotion → your mood mapping
+def map_emotion_to_mood(emotion: str):
+    if emotion == "joy":
+        return "good"
+    elif emotion == "sadness":
+        return "low"
+    elif emotion == "anger":
+        return "overwhelmed"
+    elif emotion == "fear":
+        return "stressed"
+    elif emotion == "neutral":
+        return "neutral"
+    else:
+        return "neutral"
+
+
+def analyze_text(text: str):
+    model = get_model()
+    chunks = split_text(text)
+
+    aggregated = {}
+
+    for chunk in chunks:
+        try:
+            outputs = model(chunk[:512])
+        except Exception:
+            return {
+                "label": "NEUTRAL",
+                "score": 0.5,
+                "mood": "neutral"
+            }
+
+        # Normalize output
+        if isinstance(outputs[0], list):
+            results = outputs[0]  # return_all_scores=True case
+        else:
+            results = outputs     # single prediction case
+
+        for r in results:
+            if isinstance(r, dict):
+                label = r["label"]
+                score = r["score"]
+            else:
+                # fallback if model returns string label
+                label = r
+                score = 1.0
+
+            aggregated[label] = aggregated.get(label, 0) + score
+
+    # average scores
+    for k in aggregated:
+        aggregated[k] /= len(chunks)
+
+    # pick best emotion
+    best_emotion = max(aggregated, key=aggregated.get)
+    best_score = aggregated[best_emotion]
+
+    mood = map_emotion_to_mood(best_emotion)
+
+    return {
+        "label": "POSITIVE" if mood in ["good"] else "NEGATIVE",
+        "score": float(best_score),
+        "mood": mood
+    }

mental_health/settings.py

@@ -33,7 +33,7 @@ SECRET_KEY = env('SECRET_KEY')
 DEBUG = env.bool('DEBUG', default=True)
 
 ALLOWED_HOSTS = ['*']
-
+CSRF_TRUSTED_ORIGINS = ['https://*.hf.space']
 
 # Application definition
 

requirements.txt

@@ -13,7 +13,7 @@ click==8.4.1
 colorama==0.4.6
 distro==1.9.0
 dj-database-url==3.1.2
-Django==5.2.15
+Django==6.0.5
 django-anymail==15.0
 django-cors-headers==4.9.0
 django-environ==0.13.0
@@ -22,19 +22,29 @@ django-ratelimit==4.1.0
 djangorestframework==3.17.1
 djangorestframework_simplejwt==5.5.1
 edge-tts==7.2.8
+filelock==3.29.0
 frozenlist==1.8.0
+fsspec==2026.4.0
 groq==1.2.0
 gunicorn==26.0.0
 h11==0.16.0
+hf-xet==1.5.0
 httpcore==1.0.9
 httpx==0.28.1
+huggingface_hub==1.17.0
 idna==3.17
 Jinja2==3.1.6
+joblib==1.5.3
 markdown-it-py==4.0.0
 MarkupSafe==3.0.3
 mdurl==0.1.2
+mpmath==1.3.0
 multidict==6.7.1
+networkx==3.6.1
+nltk==3.9.4
+numpy==2.4.6
 packaging==26.2
+pandas==3.0.3
 pillow==12.2.0
 propcache==0.5.2
 psutil==7.2.2
@@ -48,14 +58,26 @@ python-dateutil==2.9.0.post0
 python-dotenv==1.2.2
 python-multipart==0.0.30
 PyYAML==6.0.3
+regex==2026.5.9
 requests==2.34.2
 rich==15.0.0
+safetensors==0.7.0
+scikit-learn==1.8.0
+scipy==1.17.1
+sentence-transformers==5.5.1
 setuptools==81.0.0
 shellingham==1.5.4
 six==1.17.0
 sniffio==1.3.1
 sqlparse==0.5.5
+sympy==1.14.0
 tabulate==0.10.0
+textblob==0.20.0
+threadpoolctl==3.6.0
+tokenizers==0.22.2
+torch==2.12.0
+tqdm==4.67.3
+transformers==5.9.0
 typer==0.25.1
 typing-inspection==0.4.2
 typing_extensions==4.15.0