Add files using upload-large-folder tool

Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . ./
+
+EXPOSE 7860
+
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

PRODUCTION_READINESS.md

@@ -0,0 +1,32 @@
+# Production Readiness Audit
+
+Scope: frontend, database, features, and user experience.
+
+## High Priority Gaps
+- Auth is not secure or enforced: APIs accept `user_id` from client and return user history without verifying identity. Any client can access other users' data. Implement token-based auth and derive user_id server-side.
+- Passwords stored insecurely: client stores plaintext password in SharedPreferences; server allows plaintext fallback and uses unsalted SHA-256. Use bcrypt/argon2; remove plaintext fallback; store tokens in secure storage only.
+- Check-ins not persisted in DB: daily check-ins stored locally only. Add a `checkins` table and persist via API.
+- Database schema incomplete for core features: missing tables for check-ins, goals, sessions, etc. Add required tables and foreign keys.
+
+## Medium Priority Gaps
+- Hardcoded API base URL: no staging/production environment separation. Move to environment config.
+- Logout does not clear stored user state: it navigates without clearing saved data. Call a clear/reset routine on logout.
+- DASS scale mismatch risk: UI uses 0-4 while DASS-42 is typically 0-3. Align scale or adjust scoring logic.
+- Error handling is weak: network failures often return empty lists or generic errors. Add timeouts, retries, and user-friendly error states.
+
+## UX and Feature Completeness
+- Auto-login missing: splash always routes to onboarding even if user is logged in. Route based on `AppState.isLoggedIn`.
+- Placeholder actions: "Forgot Password", social login, profile edits are non-functional. Implement or remove until ready.
+
+## Data and Analytics Limitations
+- Analyses not fully stored: minimal fields saved; missing detailed scores/recommendations and client timestamps. Persist full output fields for analytics and debugging.
+- Indexing missing: no indexes on `created_at`/`user_id` for history queries. Add indexes for performance.
+
+## Backend Gaps
+- No auth enforcement: endpoints accept user_id from clients and return data without verifying identity. Add JWT/session auth and authorization checks.
+- Password handling is weak: unsalted SHA-256 and plaintext fallback. Move to bcrypt/argon2 and remove plaintext path.
+- CORS is wide open: `allow_origins=["*"]` with credentials. Restrict origins and limit credentials.
+- No rate limiting or abuse protection: add per-IP/user throttling on auth and analysis endpoints.
+- Error handling leaks details: raw exceptions are returned. Normalize error responses and hide internals.
+- No database migrations: relies on `create_all`. Introduce Alembic migrations and schema versioning.
+- Missing structured logging/monitoring: add request logs, tracing, and health checks.

README.md

@@ -0,0 +1,73 @@
+
+---
+title: SafeSpace API
+emoji: 🧠
+colorFrom: blue
+colorTo: green
+sdk: docker
+python_version: "3.11"
+pinned: false
+---
+
+# 🧠 Mental Health Prediction System
+
+## 📌 Project Overview
+
+This project builds a **Machine Learning system** that predicts mental health conditions based on questionnaire answers.
+
+The system predicts:
+
+- Depression Level
+- Anxiety Level
+- Stress Level
+
+The model takes questionnaire answers as input and outputs:
+
+- Percentage of Depression
+- Percentage of Anxiety
+- Percentage of Stress
+
+---
+
+# 🗺️ Project Roadmap
+
+## Phase 1 — Problem Definition
+
+### Goal
+
+Build a Machine Learning model that predicts mental health conditions from questionnaire answers.
+
+The system should:
+
+- Accept user answers
+- Predict mental health scores
+- Show percentages
+- Classify severity levels
+
+Predicted Conditions:
+
+- Depression
+- Anxiety
+- Stress
+
+---
+
+## Phase 2 — Dataset
+
+### Dataset Description
+
+The dataset contains questionnaire answers and mental health scores.
+
+### Dataset Size
+
+- Samples: **39,775**
+- Features: **42 questions**
+- Targets: **3 scores**
+
+Targets:
+
+- Depression Score
+- Anxiety Score
+- Stress Score
+
+Example Features:

index.html

@@ -0,0 +1,210 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>SafeSpace API Test</title>
+    <style>
+      :root {
+        --bg: #0f1a16;
+        --panel: #16231f;
+        --accent: #4fd1a5;
+        --accent-2: #7ce3c3;
+        --text: #e8f6f1;
+        --muted: #9bb7ad;
+        --danger: #f87171;
+        --border: #274136;
+      }
+
+      * { box-sizing: border-box; }
+
+      body {
+        margin: 0;
+        font-family: "Space Grotesk", "Figtree", "Montserrat", sans-serif;
+        background: radial-gradient(circle at 15% 10%, #193229, #0f1a16 55%);
+        color: var(--text);
+      }
+
+      header {
+        padding: 32px 24px 16px;
+        text-align: center;
+      }
+
+      header h1 {
+        margin: 0 0 8px;
+        font-size: 30px;
+        letter-spacing: 0.4px;
+      }
+
+      header p {
+        margin: 0;
+        color: var(--muted);
+      }
+
+      main {
+        max-width: 980px;
+        margin: 0 auto;
+        padding: 24px;
+        display: grid;
+        gap: 18px;
+      }
+
+      .panel {
+        background: var(--panel);
+        border: 1px solid var(--border);
+        border-radius: 18px;
+        padding: 20px;
+        box-shadow: 0 14px 34px rgba(0, 0, 0, 0.25);
+      }
+
+      label {
+        display: block;
+        font-size: 13px;
+        text-transform: uppercase;
+        letter-spacing: 1.5px;
+        color: var(--muted);
+        margin-bottom: 8px;
+      }
+
+      input, textarea {
+        width: 100%;
+        padding: 12px 14px;
+        border-radius: 12px;
+        border: 1px solid var(--border);
+        background: #0c1512;
+        color: var(--text);
+        font-size: 15px;
+      }
+
+      textarea { min-height: 120px; resize: vertical; }
+
+      .row { display: grid; gap: 12px; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); }
+
+      button {
+        border: none;
+        background: linear-gradient(120deg, var(--accent), var(--accent-2));
+        color: #062318;
+        font-weight: 700;
+        font-size: 15px;
+        padding: 12px 18px;
+        border-radius: 12px;
+        cursor: pointer;
+        transition: transform 0.2s ease, box-shadow 0.2s ease;
+        width: 100%;
+      }
+
+      button:hover { transform: translateY(-1px); box-shadow: 0 10px 18px rgba(79, 209, 165, 0.2); }
+
+      pre {
+        white-space: pre-wrap;
+        word-break: break-word;
+        background: #0b1512;
+        border: 1px solid #1f352d;
+        border-radius: 12px;
+        padding: 16px;
+        min-height: 120px;
+      }
+
+      .error { color: var(--danger); font-weight: 600; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>SafeSpace API Test</h1>
+      <p>Quickly validate AI endpoints on your Hugging Face Space.</p>
+    </header>
+
+    <main>
+      <section class="panel">
+        <div class="row">
+          <div>
+            <label for="baseUrl">Base URL</label>
+            <input id="baseUrl" value="https://AliSakr9997-safespace.hf.space" />
+          </div>
+          <div>
+            <label for="userId">User ID</label>
+            <input id="userId" value="1" />
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <label for="textInput">User Text</label>
+        <textarea id="textInput">I have been feeling overwhelmed at work and can't sleep.</textarea>
+      </section>
+
+      <section class="panel">
+        <label for="survey">Survey Answers (42 values, 0-4, comma-separated)</label>
+        <textarea id="survey">0,1,2,1,0,2,1,0,1,2,1,0,2,1,0,2,1,1,0,2,1,2,1,0,2,1,0,1,2,1,0,2,1,0,1,2,1,0,2,1,0,1</textarea>
+      </section>
+
+      <section class="panel">
+        <div class="row">
+          <button id="analyzeBtn">POST /v1/analysis</button>
+          <button id="historyBtn">GET /v1/users/{id}/analyses</button>
+        </div>
+      </section>
+
+      <section class="panel">
+        <label>Response</label>
+        <pre id="output">Waiting for request...</pre>
+      </section>
+    </main>
+
+    <script>
+      const output = document.getElementById('output');
+      const baseUrl = document.getElementById('baseUrl');
+      const userId = document.getElementById('userId');
+      const textInput = document.getElementById('textInput');
+      const survey = document.getElementById('survey');
+
+      function setOutput(data, isError = false) {
+        if (isError) {
+          output.innerHTML = '<span class="error">' + data + '</span>';
+        } else {
+          output.textContent = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+        }
+      }
+
+      function parseSurvey() {
+        return survey.value
+          .split(',')
+          .map((v) => parseInt(v.trim(), 10))
+          .filter((v) => Number.isFinite(v));
+      }
+
+      document.getElementById('analyzeBtn').addEventListener('click', async () => {
+        setOutput('Sending request...');
+        try {
+          const payload = {
+            user_id: userId.value,
+            text: textInput.value,
+            survey_answers: parseSurvey(),
+            locale: 'en',
+            client_ts: new Date().toISOString(),
+          };
+          const res = await fetch(`${baseUrl.value}/v1/analysis`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+          });
+          const json = await res.json();
+          setOutput(json);
+        } catch (err) {
+          setOutput(err.message || String(err), true);
+        }
+      });
+
+      document.getElementById('historyBtn').addEventListener('click', async () => {
+        setOutput('Fetching history...');
+        try {
+          const res = await fetch(`${baseUrl.value}/v1/users/${userId.value}/analyses?limit=20&offset=0`);
+          const json = await res.json();
+          setOutput(json);
+        } catch (err) {
+          setOutput(err.message || String(err), true);
+        }
+      });
+    </script>
+  </body>
+</html>

mental_xlmr_final/checkpoint-3670

@@ -0,0 +1 @@
+

mental_xlmr_final/config.json

@@ -0,0 +1,40 @@
+{
+  "add_cross_attention": false,
+  "architectures": [
+    "XLMRobertaForSequenceClassification"
+  ],
+  "attention_probs_dropout_prob": 0.1,
+  "bos_token_id": 0,
+  "classifier_dropout": null,
+  "dtype": "float32",
+  "eos_token_id": 2,
+  "hidden_act": "gelu",
+  "hidden_dropout_prob": 0.1,
+  "hidden_size": 768,
+  "id2label": {
+    "0": "LABEL_0",
+    "1": "LABEL_1",
+    "2": "LABEL_2"
+  },
+  "initializer_range": 0.02,
+  "intermediate_size": 3072,
+  "is_decoder": false,
+  "label2id": {
+    "LABEL_0": 0,
+    "LABEL_1": 1,
+    "LABEL_2": 2
+  },
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 514,
+  "model_type": "xlm-roberta",
+  "num_attention_heads": 12,
+  "num_hidden_layers": 12,
+  "output_past": true,
+  "pad_token_id": 1,
+  "position_embedding_type": "absolute",
+  "tie_word_embeddings": true,
+  "transformers_version": "5.0.0",
+  "type_vocab_size": 1,
+  "use_cache": false,
+  "vocab_size": 250002
+}

mental_xlmr_final/tokenizer_config.json

@@ -0,0 +1,14 @@
+{
+  "add_prefix_space": true,
+  "backend": "tokenizers",
+  "bos_token": "<s>",
+  "cls_token": "<s>",
+  "eos_token": "</s>",
+  "is_local": false,
+  "mask_token": "<mask>",
+  "model_max_length": 512,
+  "pad_token": "<pad>",
+  "sep_token": "</s>",
+  "tokenizer_class": "XLMRobertaTokenizer",
+  "unk_token": "<unk>"
+}

migrations/20260508_init.sql

@@ -0,0 +1,112 @@
+-- Initial schema and indexes for production (Postgres compatible)
+
+CREATE TABLE IF NOT EXISTS users (
+  id SERIAL PRIMARY KEY,
+  email VARCHAR(255),
+  password VARCHAR(255),
+  created_at TIMESTAMP WITHOUT TIME ZONE,
+  name TEXT
+);
+
+CREATE TABLE IF NOT EXISTS analyses (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER NULL,
+  primary_condition VARCHAR(255),
+  clinical_scoring JSON,
+  created_at TIMESTAMP WITHOUT TIME ZONE,
+  text_input TEXT,
+  text_input_hash TEXT,
+  text_scores JSONB,
+  survey_scores JSONB,
+  fused_scores JSONB,
+  severity TEXT,
+  cause TEXT,
+  suicidal_flag BOOLEAN DEFAULT FALSE,
+  model_version TEXT,
+  app_version TEXT,
+  locale TEXT
+);
+
+CREATE TABLE IF NOT EXISTS checkins (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER NOT NULL,
+  mood INTEGER NOT NULL,
+  sleep INTEGER NOT NULL,
+  energy DOUBLE PRECISION NOT NULL,
+  created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT NOW()
+);
+
+CREATE TABLE IF NOT EXISTS journal_entries (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER,
+  content TEXT NOT NULL,
+  created_at TIMESTAMP WITHOUT TIME ZONE DEFAULT NOW(),
+  updated_at TIMESTAMP WITHOUT TIME ZONE
+);
+
+CREATE TABLE IF NOT EXISTS user_preferences (
+  user_id INTEGER PRIMARY KEY,
+  theme TEXT DEFAULT 'dark',
+  language TEXT DEFAULT 'en',
+  notifications_enabled BOOLEAN DEFAULT TRUE,
+  crisis_locale TEXT
+);
+
+CREATE TABLE IF NOT EXISTS consents (
+  id SERIAL PRIMARY KEY,
+  user_id INTEGER,
+  consent_type TEXT NOT NULL,
+  granted BOOLEAN NOT NULL DEFAULT FALSE,
+  created_at TIMESTAMP WITHOUT TIME ZONE NOT NULL DEFAULT NOW()
+);
+
+CREATE INDEX IF NOT EXISTS ix_analyses_user_id_created_at ON analyses (user_id, created_at);
+CREATE INDEX IF NOT EXISTS ix_checkins_user_id_created_at ON checkins (user_id, created_at);
+
+DO $$
+BEGIN
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.table_constraints
+    WHERE constraint_name = 'fk_analyses_user'
+  ) THEN
+    ALTER TABLE analyses
+      ADD CONSTRAINT fk_analyses_user
+      FOREIGN KEY (user_id) REFERENCES users(id);
+  END IF;
+
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.table_constraints
+    WHERE constraint_name = 'fk_checkins_user'
+  ) THEN
+    ALTER TABLE checkins
+      ADD CONSTRAINT fk_checkins_user
+      FOREIGN KEY (user_id) REFERENCES users(id);
+  END IF;
+
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.table_constraints
+    WHERE constraint_name = 'fk_journal_entries_user'
+  ) THEN
+    ALTER TABLE journal_entries
+      ADD CONSTRAINT fk_journal_entries_user
+      FOREIGN KEY (user_id) REFERENCES users(id);
+  END IF;
+
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.table_constraints
+    WHERE constraint_name = 'fk_consents_user'
+  ) THEN
+    ALTER TABLE consents
+      ADD CONSTRAINT fk_consents_user
+      FOREIGN KEY (user_id) REFERENCES users(id);
+  END IF;
+
+  IF NOT EXISTS (
+    SELECT 1 FROM information_schema.table_constraints
+    WHERE constraint_name = 'fk_user_preferences_user'
+  ) THEN
+    ALTER TABLE user_preferences
+      ADD CONSTRAINT fk_user_preferences_user
+      FOREIGN KEY (user_id) REFERENCES users(id);
+  END IF;
+END $$;

scratch/check_data.py

@@ -0,0 +1,13 @@
+from sqlalchemy import create_engine, text
+import json
+
+DATABASE_URL = "postgresql://safespace:AdminAdmin@postgresql-208383-0.cloudclusters.net:19712/safespace"
+engine = create_engine(DATABASE_URL)
+
+with engine.connect() as conn:
+    result = conn.execute(text("SELECT id, user_id, primary_condition, clinical_scoring, created_at FROM analyses WHERE user_id = 102 ORDER BY created_at DESC LIMIT 10"))
+    rows = [dict(row._mapping) for row in result]
+    
+    print(f"Found {len(rows)} records for user 102")
+    for r in rows:
+        print(f"ID: {r['id']}, Date: {r['created_at']}, Primary: {r['primary_condition']}, Scores: {r['clinical_scoring']}")

temp_hf_space/api.py

@@ -0,0 +1,343 @@
+import os
+from datetime import datetime
+import hashlib
+
+import httpx
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from core_ai import predict_text, predict_survey, fuse_scores
+from recommendations import get_recommendations
+
+# --- DATABASE SETUP ---
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, JSON
+from sqlalchemy.orm import declarative_base, sessionmaker, Session
+
+DATABASE_URL = os.environ.get("DATABASE_URL")
+if DATABASE_URL and DATABASE_URL.startswith("postgres://"):
+    DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql://", 1)
+
+engine = create_engine(DATABASE_URL, connect_args={'connect_timeout': 5}) if DATABASE_URL else None
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) if engine else None
+Base = declarative_base()
+
+
+class DBUser(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=True)
+    email = Column(String, unique=True, index=True)
+    password = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class DBAnalysis(Base):
+    __tablename__ = "analyses"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, index=True, nullable=True)
+    primary_condition = Column(String)
+    clinical_scoring = Column(JSON)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+# --- APP SETUP ---
+app = FastAPI(title="SafeSpace API", version="1.0.0")
+
+
+@app.on_event("startup")
+async def startup_event():
+    import asyncio
+    if engine:
+        try:
+            await asyncio.wait_for(
+                asyncio.to_thread(Base.metadata.create_all, bind=engine),
+                timeout=8.0
+            )
+            print("Database connected and tables verified.")
+        except asyncio.TimeoutError:
+            print("Database connection timed out during startup - server will start without DB verification.")
+        except Exception as e:
+            print(f"Database connection failed during startup: {e}")
+    print("Application startup complete.")
+
+
+def get_db():
+    if not SessionLocal:
+        yield None
+    else:
+        db = SessionLocal()
+        try:
+            yield db
+        finally:
+            db.close()
+
+# Add CORS so Flutter app can communicate with it
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Password Hashing ---
+def hash_password(password: str) -> str:
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# --- DASS-42 Clinical Scoring ---
+def calculate_dass_clinical_score(answers: list) -> dict:
+    dep_idx = [2, 4, 9, 12, 15, 16, 20, 23, 25, 30, 33, 36, 37, 41]
+    anx_idx = [1, 3, 6, 8, 14, 18, 19, 22, 24, 27, 29, 35, 39, 40]
+    str_idx = [0, 5, 7, 10, 11, 13, 17, 21, 26, 28, 31, 32, 34, 38]
+
+    dep_score = sum(answers[i] for i in dep_idx)
+    anx_score = sum(answers[i] for i in anx_idx)
+    str_score = sum(answers[i] for i in str_idx)
+
+    def get_severity(score, bounds):
+        if score <= bounds[0]: return "Normal"
+        if score <= bounds[1]: return "Mild"
+        if score <= bounds[2]: return "Moderate"
+        if score <= bounds[3]: return "Severe"
+        return "Extremely Severe"
+
+    return {
+        "depression": {"score": dep_score, "severity": get_severity(dep_score, [9, 13, 20, 27])},
+        "anxiety": {"score": anx_score, "severity": get_severity(anx_score, [7, 9, 14, 19])},
+        "stress": {"score": str_score, "severity": get_severity(str_score, [14, 18, 25, 33])}
+    }
+
+# --- API MODELS ---
+class AnalysisRequest(BaseModel):
+    user_id: str | int = Field(default=None, description="User identifier")
+    text: str = Field(..., min_length=1)
+    survey_answers: list[int] = Field(..., min_items=42, max_items=42)
+    locale: str = Field(default="en")
+    client_ts: str | None = None
+
+
+class AnalyzeRequest(BaseModel):
+    text: str = Field(..., description="The user's response in text (Arabic/English)")
+    survey_answers: list[int] = Field(..., min_items=42, max_items=42, description="List of 42 integers (0-4) representing DASS-42 survey answers")
+    user_id: int | None = Field(default=None, description="Optional user ID to link analysis to a user")
+
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = "default"
+
+
+class ChatResponse(BaseModel):
+    reply: str
+
+
+class SignupRequest(BaseModel):
+    name: str = Field(..., min_length=1)
+    email: str = Field(..., min_length=5)
+    password: str = Field(..., min_length=4)
+
+
+class LoginRequest(BaseModel):
+    email: str = Field(..., min_length=5)
+    password: str = Field(..., min_length=1)
+
+
+# --- ENDPOINTS ---
+@app.get("/")
+def root():
+    return {"status": "ok", "message": "SafeSpace API"}
+
+
+@app.get("/test", response_class=HTMLResponse)
+def test_page():
+    html_path = os.path.join(os.path.dirname(__file__), "index.html")
+    if not os.path.exists(html_path):
+        raise HTTPException(status_code=404, detail="index.html not found")
+    with open(html_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# --- AUTH ENDPOINTS ---
+@app.post("/api/v1/auth/signup")
+async def signup(request: SignupRequest, db: Session = Depends(get_db)):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not available")
+
+    # Check if email already exists
+    existing = db.query(DBUser).filter(DBUser.email == request.email).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    # Create new user
+    try:
+        new_user = DBUser(
+            name=request.name,
+            email=request.email,
+            password=hash_password(request.password),
+        )
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+
+        return {
+            "user_id": new_user.id,
+            "email": new_user.email,
+            "name": new_user.name,
+            "message": "Account created successfully"
+        }
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to create account: {str(e)}")
+
+
+@app.post("/api/v1/auth/login")
+async def login(request: LoginRequest, db: Session = Depends(get_db)):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not available")
+
+    user = db.query(DBUser).filter(DBUser.email == request.email).first()
+    if not user:
+        raise HTTPException(status_code=401, detail="Email not found")
+
+    if user.password != hash_password(request.password):
+        # Also try plain-text match for legacy users who signed up before hashing
+        if user.password != request.password:
+            raise HTTPException(status_code=401, detail="Incorrect password")
+
+    return {
+        "user_id": user.id,
+        "email": user.email,
+        "name": user.name or "",
+        "message": "Login successful"
+    }
+
+
+# New-style endpoint (used by index.html test page)
+@app.post("/v1/analysis")
+def analyze(payload: AnalysisRequest, db: Session = Depends(get_db)):
+    text_scores = predict_text(payload.text)
+    survey_scores = predict_survey(payload.survey_answers)
+    final_scores = fuse_scores(text_scores, survey_scores)
+    primary = max(final_scores, key=final_scores.get)
+    clinical = calculate_dass_clinical_score(payload.survey_answers)
+    rec = get_recommendations(primary, final_scores[primary], payload.text)
+
+    # Save to PostgreSQL if DB is connected
+    if db:
+        try:
+            new_analysis = DBAnalysis(
+                primary_condition=primary,
+                clinical_scoring=clinical
+            )
+            db.add(new_analysis)
+            db.commit()
+        except Exception as e:
+            print(f"DB save error: {e}")
+
+    return {
+        "analysis_id": None,
+        "primary": primary,
+        "scores": final_scores,
+        "severity": rec.get("severity"),
+        "cause": rec.get("cause"),
+        "recommendations": {
+            "tips_en": rec.get("tips_en", []),
+            "tips_ar": rec.get("tips_ar", []),
+            "resources_en": rec.get("resources_en", []),
+            "resources_ar": rec.get("resources_ar", []),
+            "referral_en": rec.get("referral_en", ""),
+            "referral_ar": rec.get("referral_ar", ""),
+        },
+        "suicidal_flag": rec.get("suicidal_flag", False),
+        "created_at": datetime.utcnow().isoformat() + "Z",
+    }
+
+# Flutter-compatible endpoint (used by api_service.dart)
+@app.post("/api/v1/analyze")
+async def analyze_mental_health(request: AnalyzeRequest, db: Session = Depends(get_db)):
+    try:
+        text_scores = predict_text(request.text)
+        survey_scores = predict_survey(request.survey_answers)
+        final_scores = fuse_scores(text_scores, survey_scores)
+        primary = max(final_scores, key=final_scores.get)
+        clinical = calculate_dass_clinical_score(request.survey_answers)
+        rec = get_recommendations(primary, final_scores[primary], request.text)
+
+        # Save to PostgreSQL if DB is connected
+        if db:
+            try:
+                new_analysis = DBAnalysis(
+                    user_id=request.user_id,
+                    primary_condition=primary,
+                    clinical_scoring=clinical
+                )
+                db.add(new_analysis)
+                db.commit()
+            except Exception as e:
+                print(f"DB save error: {e}")
+
+        return {
+            "primary_condition": primary,
+            "fused_scores": final_scores,
+            "text_scores": text_scores,
+            "survey_scores": survey_scores,
+            "clinical_scoring": clinical,
+            "recommendations": rec
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Flutter-compatible history endpoint
+@app.get("/api/v1/analyses/history")
+async def get_analyses_history(user_id: int = None, db: Session = Depends(get_db)):
+    try:
+        if not db:
+            return []
+
+        query = db.query(DBAnalysis)
+
+        # Filter by user_id if provided
+        if user_id is not None:
+            query = query.filter(DBAnalysis.user_id == user_id)
+
+        # Get the 10 most recent analyses, sorted by created_at ascending (oldest first for graphing)
+        records = query.order_by(DBAnalysis.created_at.desc()).limit(10).all()
+
+        history = []
+        for r in reversed(records):  # Reverse so oldest is first
+            if r.clinical_scoring:
+                history.append({
+                    "id": r.id,
+                    "date": r.created_at.strftime("%b %d"),
+                    "depression": r.clinical_scoring.get("depression", {}).get("score", 0),
+                    "anxiety": r.clinical_scoring.get("anxiety", {}).get("score", 0),
+                    "stress": r.clinical_scoring.get("stress", {}).get("score", 0),
+                    "primary": r.primary_condition
+                })
+        return history
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/v1/chat", response_model=ChatResponse)
+async def chat_with_ai(request: ChatRequest):
+    api_url = os.environ.get("AI_API_URL")
+    api_key = os.environ.get("AI_API_KEY")
+    chatflow_id = os.environ.get("AI_CHATFLOW_ID")
+
+    if not api_url or not api_key or not chatflow_id:
+        raise HTTPException(status_code=500, detail="AI API credentials are not configured in Secrets.")
+
+    endpoint = f"{api_url}/api/v1/prediction/{chatflow_id}"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    payload = {"question": request.message, "overrideConfig": {"sessionId": request.session_id}}
+
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(endpoint, json=payload, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            data = response.json()
+            return ChatResponse(reply=data.get("text") or data.get("answer") or str(data))
+        except Exception as e:
+            raise HTTPException(status_code=502, detail=f"Failed to communicate with AI API: {str(e)}")

temp_space/.gitattributes

@@ -0,0 +1,53 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/data.csv filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/mental_xlmr_final/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/.dart_tool/chrome-device/Default/History filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/.dart_tool/chrome-device/Default/shared_proto_db/000003.log filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/.dart_tool/chrome-device/Default/Web[[:space:]]Data filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/build/8730b13ca0249799964d0a71255a8f3b.cache.dill.track.dill filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/build/flutter_assets/fonts/MaterialIcons-Regular.otf filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/build/flutter_assets/packages/cupertino_icons/assets/CupertinoIcons.ttf filter=lfs diff=lfs merge=lfs -text
+clean_git_repo/UI/safespace/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png filter=lfs diff=lfs merge=lfs -text
+data.csv filter=lfs diff=lfs merge=lfs -text
+mental_xlmr_final/tokenizer.json filter=lfs diff=lfs merge=lfs -text
+UI/safespace/.dart_tool/chrome-device/Default/History filter=lfs diff=lfs merge=lfs -text
+UI/safespace/.dart_tool/chrome-device/Default/shared_proto_db/000003.log filter=lfs diff=lfs merge=lfs -text
+UI/safespace/.dart_tool/chrome-device/Default/Web[[:space:]]Data filter=lfs diff=lfs merge=lfs -text
+UI/safespace/build/8730b13ca0249799964d0a71255a8f3b.cache.dill.track.dill filter=lfs diff=lfs merge=lfs -text
+UI/safespace/build/flutter_assets/fonts/MaterialIcons-Regular.otf filter=lfs diff=lfs merge=lfs -text
+UI/safespace/build/flutter_assets/packages/cupertino_icons/assets/CupertinoIcons.ttf filter=lfs diff=lfs merge=lfs -text
+UI/safespace/macos/Runner/Assets.xcassets/AppIcon.appiconset/app_icon_1024.png filter=lfs diff=lfs merge=lfs -text

temp_space/.gitignore

@@ -0,0 +1,2 @@
+
+push_to_space.py

temp_space/Dockerfile

@@ -0,0 +1,19 @@
+FROM python:3.11-slim
+
+WORKDIR /app
+
+ENV PYTHONDONTWRITEBYTECODE=1
+ENV PYTHONUNBUFFERED=1
+
+RUN apt-get update \
+    && apt-get install -y --no-install-recommends build-essential \
+    && rm -rf /var/lib/apt/lists/*
+
+COPY requirements.txt ./
+RUN pip install --no-cache-dir -r requirements.txt
+
+COPY . ./
+
+EXPOSE 7860
+
+CMD ["uvicorn", "api:app", "--host", "0.0.0.0", "--port", "7860"]

temp_space/api.py

@@ -0,0 +1,360 @@
+import os
+from datetime import datetime
+import hashlib
+
+import httpx
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from core_ai import predict_text, predict_survey, fuse_scores
+from recommendations import get_recommendations
+
+# --- DATABASE SETUP ---
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, JSON
+from sqlalchemy.orm import declarative_base, sessionmaker, Session
+
+DATABASE_URL = os.environ.get("DATABASE_URL")
+if DATABASE_URL and DATABASE_URL.startswith("postgres://"):
+    DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql://", 1)
+
+engine = create_engine(DATABASE_URL, connect_args={'connect_timeout': 5}) if DATABASE_URL else None
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) if engine else None
+Base = declarative_base()
+
+
+class DBUser(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=True)
+    email = Column(String, unique=True, index=True)
+    password = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class DBAnalysis(Base):
+    __tablename__ = "analyses"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, index=True, nullable=True)
+    primary_condition = Column(String)
+    clinical_scoring = Column(JSON)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+# --- APP SETUP ---
+app = FastAPI(title="SafeSpace API", version="1.0.0")
+
+
+@app.on_event("startup")
+async def startup_event():
+    import asyncio
+    if engine:
+        try:
+            await asyncio.wait_for(
+                asyncio.to_thread(Base.metadata.create_all, bind=engine),
+                timeout=8.0
+            )
+            print("Database connected and tables verified.")
+        except asyncio.TimeoutError:
+            print("Database connection timed out during startup - server will start without DB verification.")
+        except Exception as e:
+            print(f"Database connection failed during startup: {e}")
+    print("Application startup complete.")
+
+
+def get_db():
+    if not SessionLocal:
+        yield None
+    else:
+        db = SessionLocal()
+        try:
+            yield db
+        finally:
+            db.close()
+
+# Add CORS so Flutter app can communicate with it
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Password Hashing ---
+def hash_password(password: str) -> str:
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# --- DASS-42 Clinical Scoring ---
+def calculate_dass_clinical_score(answers: list) -> dict:
+    dep_idx = [2, 4, 9, 12, 15, 16, 20, 23, 25, 30, 33, 36, 37, 41]
+    anx_idx = [1, 3, 6, 8, 14, 18, 19, 22, 24, 27, 29, 35, 39, 40]
+    str_idx = [0, 5, 7, 10, 11, 13, 17, 21, 26, 28, 31, 32, 34, 38]
+
+    dep_score = sum(answers[i] for i in dep_idx)
+    anx_score = sum(answers[i] for i in anx_idx)
+    str_score = sum(answers[i] for i in str_idx)
+
+    def get_severity(score, bounds):
+        if score <= bounds[0]: return "Normal"
+        if score <= bounds[1]: return "Mild"
+        if score <= bounds[2]: return "Moderate"
+        if score <= bounds[3]: return "Severe"
+        return "Extremely Severe"
+
+    return {
+        "depression": {"score": dep_score, "severity": get_severity(dep_score, [9, 13, 20, 27])},
+        "anxiety": {"score": anx_score, "severity": get_severity(anx_score, [7, 9, 14, 19])},
+        "stress": {"score": str_score, "severity": get_severity(str_score, [14, 18, 25, 33])}
+    }
+
+# --- API MODELS ---
+class AnalysisRequest(BaseModel):
+    user_id: str | int = Field(default=None, description="User identifier")
+    text: str = Field(..., min_length=1)
+    survey_answers: list[int] = Field(..., min_items=42, max_items=42)
+    locale: str = Field(default="en")
+    client_ts: str | None = None
+
+
+class AnalyzeRequest(BaseModel):
+    text: str = Field(..., description="The user's response in text (Arabic/English)")
+    survey_answers: list[int] = Field(..., min_items=42, max_items=42, description="List of 42 integers (0-4) representing DASS-42 survey answers")
+    user_id: int | None = Field(default=None, description="Optional user ID to link analysis to a user")
+
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = "default"
+
+
+class ChatResponse(BaseModel):
+    reply: str
+
+
+class SignupRequest(BaseModel):
+    name: str = Field(..., min_length=1)
+    email: str = Field(..., min_length=5)
+    password: str = Field(..., min_length=4)
+
+
+class LoginRequest(BaseModel):
+    email: str = Field(..., min_length=5)
+    password: str = Field(..., min_length=1)
+
+
+# --- ENDPOINTS ---
+@app.get("/")
+def root():
+    return {"status": "ok", "message": "SafeSpace API"}
+
+
+@app.get("/test", response_class=HTMLResponse)
+def test_page():
+    html_path = os.path.join(os.path.dirname(__file__), "index.html")
+    if not os.path.exists(html_path):
+        raise HTTPException(status_code=404, detail="index.html not found")
+    with open(html_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# --- AUTH ENDPOINTS ---
+@app.post("/api/v1/auth/signup")
+async def signup(request: SignupRequest, db: Session = Depends(get_db)):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not available")
+
+    # Check if email already exists
+    existing = db.query(DBUser).filter(DBUser.email == request.email).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    # Create new user
+    try:
+        new_user = DBUser(
+            name=request.name,
+            email=request.email,
+            password=hash_password(request.password),
+        )
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+
+        return {
+            "user_id": new_user.id,
+            "email": new_user.email,
+            "name": new_user.name,
+            "message": "Account created successfully"
+        }
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to create account: {str(e)}")
+
+
+@app.post("/api/v1/auth/login")
+async def login(request: LoginRequest, db: Session = Depends(get_db)):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not available")
+
+    user = db.query(DBUser).filter(DBUser.email == request.email).first()
+    if not user:
+        raise HTTPException(status_code=401, detail="Email not found")
+
+    if user.password != hash_password(request.password):
+        # Also try plain-text match for legacy users who signed up before hashing
+        if user.password != request.password:
+            raise HTTPException(status_code=401, detail="Incorrect password")
+
+    return {
+        "user_id": user.id,
+        "email": user.email,
+        "name": user.name or "",
+        "message": "Login successful"
+    }
+
+
+# New-style endpoint (used by index.html test page)
+@app.post("/v1/analysis")
+def analyze(payload: AnalysisRequest, db: Session = Depends(get_db)):
+    text_scores = predict_text(payload.text)
+    survey_scores = predict_survey(payload.survey_answers)
+    final_scores = fuse_scores(text_scores, survey_scores)
+    primary = max(final_scores, key=final_scores.get)
+    clinical = calculate_dass_clinical_score(payload.survey_answers)
+    rec = get_recommendations(primary, final_scores[primary], payload.text)
+    created_at = datetime.utcnow().isoformat() + "Z"
+
+    # Save to PostgreSQL if DB is connected
+    if db:
+        try:
+            new_analysis = DBAnalysis(
+                primary_condition=primary,
+                clinical_scoring=clinical
+            )
+            db.add(new_analysis)
+            db.commit()
+        except Exception as e:
+            print(f"DB save error: {e}")
+
+    return {
+        "analysis_id": None,
+        "primary_condition": primary,
+        "fused_scores": final_scores,
+        "text_scores": text_scores,
+        "survey_scores": survey_scores,
+        "clinical_scoring": clinical,
+        "severity": rec.get("severity"),
+        "cause": rec.get("cause"),
+        "recommendations": {
+            "tips_en": rec.get("tips_en", []),
+            "tips_ar": rec.get("tips_ar", []),
+            "resources_en": rec.get("resources_en", []),
+            "resources_ar": rec.get("resources_ar", []),
+            "referral_en": rec.get("referral_en", ""),
+            "referral_ar": rec.get("referral_ar", ""),
+        },
+        "suicidal_flag": rec.get("suicidal_flag", False),
+        "created_at": created_at,
+    }
+
+# Flutter-compatible endpoint (used by api_service.dart)
+@app.post("/api/v1/analyze")
+async def analyze_mental_health(request: AnalyzeRequest, db: Session = Depends(get_db)):
+    try:
+        text_scores = predict_text(request.text)
+        survey_scores = predict_survey(request.survey_answers)
+        final_scores = fuse_scores(text_scores, survey_scores)
+        primary = max(final_scores, key=final_scores.get)
+        clinical = calculate_dass_clinical_score(request.survey_answers)
+        rec = get_recommendations(primary, final_scores[primary], request.text)
+        created_at = datetime.utcnow().isoformat() + "Z"
+
+        # Save to PostgreSQL if DB is connected
+        if db:
+            try:
+                new_analysis = DBAnalysis(
+                    user_id=request.user_id,
+                    primary_condition=primary,
+                    clinical_scoring=clinical
+                )
+                db.add(new_analysis)
+                db.commit()
+            except Exception as e:
+                print(f"DB save error: {e}")
+
+        return {
+            "analysis_id": None,
+            "primary_condition": primary,
+            "fused_scores": final_scores,
+            "text_scores": text_scores,
+            "survey_scores": survey_scores,
+            "clinical_scoring": clinical,
+            "severity": rec.get("severity"),
+            "cause": rec.get("cause"),
+            "recommendations": {
+                "tips_en": rec.get("tips_en", []),
+                "tips_ar": rec.get("tips_ar", []),
+                "resources_en": rec.get("resources_en", []),
+                "resources_ar": rec.get("resources_ar", []),
+                "referral_en": rec.get("referral_en", ""),
+                "referral_ar": rec.get("referral_ar", ""),
+            },
+            "suicidal_flag": rec.get("suicidal_flag", False),
+            "created_at": created_at,
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Flutter-compatible history endpoint
+@app.get("/api/v1/analyses/history")
+async def get_analyses_history(user_id: int = None, db: Session = Depends(get_db)):
+    try:
+        if not db:
+            return []
+
+        query = db.query(DBAnalysis)
+
+        # Filter by user_id if provided
+        if user_id is not None:
+            query = query.filter(DBAnalysis.user_id == user_id)
+
+        # Get the 10 most recent analyses, sorted by created_at ascending (oldest first for graphing)
+        records = query.order_by(DBAnalysis.created_at.desc()).limit(10).all()
+
+        history = []
+        for r in reversed(records):  # Reverse so oldest is first
+            if r.clinical_scoring:
+                history.append({
+                    "id": r.id,
+                    "date": r.created_at.strftime("%b %d"),
+                    "depression": r.clinical_scoring.get("depression", {}).get("score", 0),
+                    "anxiety": r.clinical_scoring.get("anxiety", {}).get("score", 0),
+                    "stress": r.clinical_scoring.get("stress", {}).get("score", 0),
+                    "primary": r.primary_condition
+                })
+        return history
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/v1/chat", response_model=ChatResponse)
+async def chat_with_ai(request: ChatRequest):
+    api_url = os.environ.get("AI_API_URL")
+    api_key = os.environ.get("AI_API_KEY")
+    chatflow_id = os.environ.get("AI_CHATFLOW_ID")
+
+    if not api_url or not api_key or not chatflow_id:
+        raise HTTPException(status_code=500, detail="AI API credentials are not configured in Secrets.")
+
+    endpoint = f"{api_url}/api/v1/prediction/{chatflow_id}"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    payload = {"question": request.message, "overrideConfig": {"sessionId": request.session_id}}
+
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(endpoint, json=payload, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            data = response.json()
+            return ChatResponse(reply=data.get("text") or data.get("answer") or str(data))
+        except Exception as e:
+            raise HTTPException(status_code=502, detail=f"Failed to communicate with AI API: {str(e)}")

temp_space/core_ai.py

@@ -0,0 +1,89 @@
+import os
+import re
+import pickle
+import warnings
+from functools import lru_cache
+
+import numpy as np
+import torch
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+from deep_translator import GoogleTranslator
+
+warnings.filterwarnings("ignore")
+
+CLASSES = ["anxiety", "depression", "stress"]
+
+
+@lru_cache(maxsize=1)
+def load_xlmr():
+    model_id = os.getenv("HF_MODEL_ID", "AliSakr9997/Mental-XLMR-Model")
+    token = os.getenv("HF_TOKEN")
+    kwargs = {"token": token} if token else {}
+    local_dir = os.path.join(os.path.dirname(__file__), "mental_xlmr_final")
+    local_weights = any(
+        os.path.exists(os.path.join(local_dir, fname))
+        for fname in ("pytorch_model.bin", "model.safetensors")
+    )
+    source = local_dir if local_weights else model_id
+    tokenizer = AutoTokenizer.from_pretrained(source, **kwargs)
+    model = AutoModelForSequenceClassification.from_pretrained(source, **kwargs)
+    le_path = os.path.join(os.path.dirname(__file__), "mental_xlmr_final", "label_encoder.pkl")
+    with open(le_path, "rb") as f:
+        le = pickle.load(f)
+    model.eval()
+    return tokenizer, model, le
+
+
+@lru_cache(maxsize=1)
+def load_survey():
+    scaler = pickle.load(open(os.path.join(os.path.dirname(__file__), "scaler.pkl"), "rb"))
+    weights = pickle.load(open(os.path.join(os.path.dirname(__file__), "model_weights.pkl"), "rb"))
+
+    def predict(x):
+        for w in weights:
+            if len(w) == 2:
+                x = np.dot(x, w[0]) + w[1]
+                x = np.maximum(0, x)
+        x = np.exp(x) / np.sum(np.exp(x))
+        return x
+
+    return scaler, predict
+
+
+def clean_text(text: str) -> str:
+    text = re.sub(r"(.)\1{2,}", r"\1\1", text)
+    text = re.sub(r"[^\w\s\u0600-\u06FF\[\]]", " ", text)
+    return re.sub(r"\s+", " ", text).strip()
+
+
+def translate_to_en(text: str) -> str:
+    try:
+        return GoogleTranslator(source="auto", target="en").translate(text)
+    except Exception:
+        return ""
+
+
+def predict_text(text: str) -> dict:
+    tokenizer, model, le = load_xlmr()
+    cleaned = clean_text(text)
+    text_en = translate_to_en(cleaned)
+    combined = (text_en + " [SEP] " + cleaned) if text_en else cleaned
+    inputs = tokenizer(combined, return_tensors="pt", truncation=True, max_length=192, padding=True)
+    with torch.no_grad():
+        probs = torch.softmax(model(**inputs).logits, dim=-1).squeeze().numpy()
+    return {c: round(float(p), 4) for c, p in zip(le.classes_, probs)}
+
+
+def predict_survey(answers: list) -> dict:
+    scaler, survey_predict = load_survey()
+    data = scaler.transform(np.array(answers).reshape(1, -1))
+    pred = survey_predict(data)[0]
+    return {
+        "depression": round(float(pred[0]), 4),
+        "anxiety": round(float(pred[1]), 4),
+        "stress": round(float(pred[2]), 4),
+    }
+
+
+def fuse_scores(text_s, survey_s, w_text=0.4, w_survey=0.6):
+    return {c: round(w_text * text_s[c] + w_survey * survey_s[c], 4) for c in CLASSES}

temp_space/index.html

@@ -0,0 +1,210 @@
+<!DOCTYPE html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>SafeSpace API Test</title>
+    <style>
+      :root {
+        --bg: #0f1a16;
+        --panel: #16231f;
+        --accent: #4fd1a5;
+        --accent-2: #7ce3c3;
+        --text: #e8f6f1;
+        --muted: #9bb7ad;
+        --danger: #f87171;
+        --border: #274136;
+      }
+
+      * { box-sizing: border-box; }
+
+      body {
+        margin: 0;
+        font-family: "Space Grotesk", "Figtree", "Montserrat", sans-serif;
+        background: radial-gradient(circle at 15% 10%, #193229, #0f1a16 55%);
+        color: var(--text);
+      }
+
+      header {
+        padding: 32px 24px 16px;
+        text-align: center;
+      }
+
+      header h1 {
+        margin: 0 0 8px;
+        font-size: 30px;
+        letter-spacing: 0.4px;
+      }
+
+      header p {
+        margin: 0;
+        color: var(--muted);
+      }
+
+      main {
+        max-width: 980px;
+        margin: 0 auto;
+        padding: 24px;
+        display: grid;
+        gap: 18px;
+      }
+
+      .panel {
+        background: var(--panel);
+        border: 1px solid var(--border);
+        border-radius: 18px;
+        padding: 20px;
+        box-shadow: 0 14px 34px rgba(0, 0, 0, 0.25);
+      }
+
+      label {
+        display: block;
+        font-size: 13px;
+        text-transform: uppercase;
+        letter-spacing: 1.5px;
+        color: var(--muted);
+        margin-bottom: 8px;
+      }
+
+      input, textarea {
+        width: 100%;
+        padding: 12px 14px;
+        border-radius: 12px;
+        border: 1px solid var(--border);
+        background: #0c1512;
+        color: var(--text);
+        font-size: 15px;
+      }
+
+      textarea { min-height: 120px; resize: vertical; }
+
+      .row { display: grid; gap: 12px; grid-template-columns: repeat(auto-fit, minmax(220px, 1fr)); }
+
+      button {
+        border: none;
+        background: linear-gradient(120deg, var(--accent), var(--accent-2));
+        color: #062318;
+        font-weight: 700;
+        font-size: 15px;
+        padding: 12px 18px;
+        border-radius: 12px;
+        cursor: pointer;
+        transition: transform 0.2s ease, box-shadow 0.2s ease;
+        width: 100%;
+      }
+
+      button:hover { transform: translateY(-1px); box-shadow: 0 10px 18px rgba(79, 209, 165, 0.2); }
+
+      pre {
+        white-space: pre-wrap;
+        word-break: break-word;
+        background: #0b1512;
+        border: 1px solid #1f352d;
+        border-radius: 12px;
+        padding: 16px;
+        min-height: 120px;
+      }
+
+      .error { color: var(--danger); font-weight: 600; }
+    </style>
+  </head>
+  <body>
+    <header>
+      <h1>SafeSpace API Test</h1>
+      <p>Quickly validate AI endpoints on your Hugging Face Space.</p>
+    </header>
+
+    <main>
+      <section class="panel">
+        <div class="row">
+          <div>
+            <label for="baseUrl">Base URL</label>
+            <input id="baseUrl" value="https://AliSakr9997-safespace.hf.space" />
+          </div>
+          <div>
+            <label for="userId">User ID</label>
+            <input id="userId" value="1" />
+          </div>
+        </div>
+      </section>
+
+      <section class="panel">
+        <label for="textInput">User Text</label>
+        <textarea id="textInput">I have been feeling overwhelmed at work and can't sleep.</textarea>
+      </section>
+
+      <section class="panel">
+        <label for="survey">Survey Answers (42 values, 0-4, comma-separated)</label>
+        <textarea id="survey">0,1,2,1,0,2,1,0,1,2,1,0,2,1,0,2,1,1,0,2,1,2,1,0,2,1,0,1,2,1,0,2,1,0,1,2,1,0,2,1,0,1</textarea>
+      </section>
+
+      <section class="panel">
+        <div class="row">
+          <button id="analyzeBtn">POST /v1/analysis</button>
+          <button id="historyBtn">GET /v1/users/{id}/analyses</button>
+        </div>
+      </section>
+
+      <section class="panel">
+        <label>Response</label>
+        <pre id="output">Waiting for request...</pre>
+      </section>
+    </main>
+
+    <script>
+      const output = document.getElementById('output');
+      const baseUrl = document.getElementById('baseUrl');
+      const userId = document.getElementById('userId');
+      const textInput = document.getElementById('textInput');
+      const survey = document.getElementById('survey');
+
+      function setOutput(data, isError = false) {
+        if (isError) {
+          output.innerHTML = '<span class="error">' + data + '</span>';
+        } else {
+          output.textContent = typeof data === 'string' ? data : JSON.stringify(data, null, 2);
+        }
+      }
+
+      function parseSurvey() {
+        return survey.value
+          .split(',')
+          .map((v) => parseInt(v.trim(), 10))
+          .filter((v) => Number.isFinite(v));
+      }
+
+      document.getElementById('analyzeBtn').addEventListener('click', async () => {
+        setOutput('Sending request...');
+        try {
+          const payload = {
+            user_id: userId.value,
+            text: textInput.value,
+            survey_answers: parseSurvey(),
+            locale: 'en',
+            client_ts: new Date().toISOString(),
+          };
+          const res = await fetch(`${baseUrl.value}/v1/analysis`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(payload),
+          });
+          const json = await res.json();
+          setOutput(json);
+        } catch (err) {
+          setOutput(err.message || String(err), true);
+        }
+      });
+
+      document.getElementById('historyBtn').addEventListener('click', async () => {
+        setOutput('Fetching history...');
+        try {
+          const res = await fetch(`${baseUrl.value}/v1/users/${userId.value}/analyses?limit=20&offset=0`);
+          const json = await res.json();
+          setOutput(json);
+        } catch (err) {
+          setOutput(err.message || String(err), true);
+        }
+      });
+    </script>
+  </body>
+</html>

temp_space/main.py

@@ -0,0 +1,343 @@
+import os
+from datetime import datetime
+import hashlib
+
+import httpx
+from fastapi import FastAPI, HTTPException, Depends
+from fastapi.responses import HTMLResponse
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel, Field
+from typing import Optional
+
+from core_ai import predict_text, predict_survey, fuse_scores
+from recommendations import get_recommendations
+
+# --- DATABASE SETUP ---
+from sqlalchemy import create_engine, Column, Integer, String, Float, DateTime, JSON
+from sqlalchemy.orm import declarative_base, sessionmaker, Session
+
+DATABASE_URL = os.environ.get("DATABASE_URL")
+if DATABASE_URL and DATABASE_URL.startswith("postgres://"):
+    DATABASE_URL = DATABASE_URL.replace("postgres://", "postgresql://", 1)
+
+engine = create_engine(DATABASE_URL, connect_args={'connect_timeout': 5}) if DATABASE_URL else None
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine) if engine else None
+Base = declarative_base()
+
+
+class DBUser(Base):
+    __tablename__ = "users"
+    id = Column(Integer, primary_key=True, index=True)
+    name = Column(String, nullable=True)
+    email = Column(String, unique=True, index=True)
+    password = Column(String)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+
+class DBAnalysis(Base):
+    __tablename__ = "analyses"
+    id = Column(Integer, primary_key=True, index=True)
+    user_id = Column(Integer, index=True, nullable=True)
+    primary_condition = Column(String)
+    clinical_scoring = Column(JSON)
+    created_at = Column(DateTime, default=datetime.utcnow)
+
+# --- APP SETUP ---
+app = FastAPI(title="SafeSpace API", version="1.0.0")
+
+
+@app.on_event("startup")
+async def startup_event():
+    import asyncio
+    if engine:
+        try:
+            await asyncio.wait_for(
+                asyncio.to_thread(Base.metadata.create_all, bind=engine),
+                timeout=8.0
+            )
+            print("Database connected and tables verified.")
+        except asyncio.TimeoutError:
+            print("Database connection timed out during startup - server will start without DB verification.")
+        except Exception as e:
+            print(f"Database connection failed during startup: {e}")
+    print("Application startup complete.")
+
+
+def get_db():
+    if not SessionLocal:
+        yield None
+    else:
+        db = SessionLocal()
+        try:
+            yield db
+        finally:
+            db.close()
+
+# Add CORS so Flutter app can communicate with it
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# --- Password Hashing ---
+def hash_password(password: str) -> str:
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# --- DASS-42 Clinical Scoring ---
+def calculate_dass_clinical_score(answers: list) -> dict:
+    dep_idx = [2, 4, 9, 12, 15, 16, 20, 23, 25, 30, 33, 36, 37, 41]
+    anx_idx = [1, 3, 6, 8, 14, 18, 19, 22, 24, 27, 29, 35, 39, 40]
+    str_idx = [0, 5, 7, 10, 11, 13, 17, 21, 26, 28, 31, 32, 34, 38]
+
+    dep_score = sum(answers[i] for i in dep_idx)
+    anx_score = sum(answers[i] for i in anx_idx)
+    str_score = sum(answers[i] for i in str_idx)
+
+    def get_severity(score, bounds):
+        if score <= bounds[0]: return "Normal"
+        if score <= bounds[1]: return "Mild"
+        if score <= bounds[2]: return "Moderate"
+        if score <= bounds[3]: return "Severe"
+        return "Extremely Severe"
+
+    return {
+        "depression": {"score": dep_score, "severity": get_severity(dep_score, [9, 13, 20, 27])},
+        "anxiety": {"score": anx_score, "severity": get_severity(anx_score, [7, 9, 14, 19])},
+        "stress": {"score": str_score, "severity": get_severity(str_score, [14, 18, 25, 33])}
+    }
+
+# --- API MODELS ---
+class AnalysisRequest(BaseModel):
+    user_id: str | int = Field(default=None, description="User identifier")
+    text: str = Field(..., min_length=1)
+    survey_answers: list[int] = Field(..., min_items=42, max_items=42)
+    locale: str = Field(default="en")
+    client_ts: str | None = None
+
+
+class AnalyzeRequest(BaseModel):
+    text: str = Field(..., description="The user's response in text (Arabic/English)")
+    survey_answers: list[int] = Field(..., min_items=42, max_items=42, description="List of 42 integers (0-4) representing DASS-42 survey answers")
+    user_id: int | None = Field(default=None, description="Optional user ID to link analysis to a user")
+
+
+class ChatRequest(BaseModel):
+    message: str
+    session_id: Optional[str] = "default"
+
+
+class ChatResponse(BaseModel):
+    reply: str
+
+
+class SignupRequest(BaseModel):
+    name: str = Field(..., min_length=1)
+    email: str = Field(..., min_length=5)
+    password: str = Field(..., min_length=4)
+
+
+class LoginRequest(BaseModel):
+    email: str = Field(..., min_length=5)
+    password: str = Field(..., min_length=1)
+
+
+# --- ENDPOINTS ---
+@app.get("/")
+def root():
+    return {"status": "ok", "message": "SafeSpace API"}
+
+
+@app.get("/test", response_class=HTMLResponse)
+def test_page():
+    html_path = os.path.join(os.path.dirname(__file__), "index.html")
+    if not os.path.exists(html_path):
+        raise HTTPException(status_code=404, detail="index.html not found")
+    with open(html_path, "r", encoding="utf-8") as f:
+        return f.read()
+
+
+# --- AUTH ENDPOINTS ---
+@app.post("/api/v1/auth/signup")
+async def signup(request: SignupRequest, db: Session = Depends(get_db)):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not available")
+
+    # Check if email already exists
+    existing = db.query(DBUser).filter(DBUser.email == request.email).first()
+    if existing:
+        raise HTTPException(status_code=400, detail="Email already registered")
+
+    # Create new user
+    try:
+        new_user = DBUser(
+            name=request.name,
+            email=request.email,
+            password=hash_password(request.password),
+        )
+        db.add(new_user)
+        db.commit()
+        db.refresh(new_user)
+
+        return {
+            "user_id": new_user.id,
+            "email": new_user.email,
+            "name": new_user.name,
+            "message": "Account created successfully"
+        }
+    except Exception as e:
+        db.rollback()
+        raise HTTPException(status_code=500, detail=f"Failed to create account: {str(e)}")
+
+
+@app.post("/api/v1/auth/login")
+async def login(request: LoginRequest, db: Session = Depends(get_db)):
+    if not db:
+        raise HTTPException(status_code=500, detail="Database not available")
+
+    user = db.query(DBUser).filter(DBUser.email == request.email).first()
+    if not user:
+        raise HTTPException(status_code=401, detail="Email not found")
+
+    if user.password != hash_password(request.password):
+        # Also try plain-text match for legacy users who signed up before hashing
+        if user.password != request.password:
+            raise HTTPException(status_code=401, detail="Incorrect password")
+
+    return {
+        "user_id": user.id,
+        "email": user.email,
+        "name": user.name or "",
+        "message": "Login successful"
+    }
+
+
+# New-style endpoint (used by index.html test page)
+@app.post("/v1/analysis")
+def analyze(payload: AnalysisRequest, db: Session = Depends(get_db)):
+    text_scores = predict_text(payload.text)
+    survey_scores = predict_survey(payload.survey_answers)
+    final_scores = fuse_scores(text_scores, survey_scores)
+    primary = max(final_scores, key=final_scores.get)
+    clinical = calculate_dass_clinical_score(payload.survey_answers)
+    rec = get_recommendations(primary, final_scores[primary], payload.text)
+
+    # Save to PostgreSQL if DB is connected
+    if db:
+        try:
+            new_analysis = DBAnalysis(
+                primary_condition=primary,
+                clinical_scoring=clinical
+            )
+            db.add(new_analysis)
+            db.commit()
+        except Exception as e:
+            print(f"DB save error: {e}")
+
+    return {
+        "analysis_id": None,
+        "primary": primary,
+        "scores": final_scores,
+        "severity": rec.get("severity"),
+        "cause": rec.get("cause"),
+        "recommendations": {
+            "tips_en": rec.get("tips_en", []),
+            "tips_ar": rec.get("tips_ar", []),
+            "resources_en": rec.get("resources_en", []),
+            "resources_ar": rec.get("resources_ar", []),
+            "referral_en": rec.get("referral_en", ""),
+            "referral_ar": rec.get("referral_ar", ""),
+        },
+        "suicidal_flag": rec.get("suicidal_flag", False),
+        "created_at": datetime.utcnow().isoformat() + "Z",
+    }
+
+# Flutter-compatible endpoint (used by api_service.dart)
+@app.post("/api/v1/analyze")
+async def analyze_mental_health(request: AnalyzeRequest, db: Session = Depends(get_db)):
+    try:
+        text_scores = predict_text(request.text)
+        survey_scores = predict_survey(request.survey_answers)
+        final_scores = fuse_scores(text_scores, survey_scores)
+        primary = max(final_scores, key=final_scores.get)
+        clinical = calculate_dass_clinical_score(request.survey_answers)
+        rec = get_recommendations(primary, final_scores[primary], request.text)
+
+        # Save to PostgreSQL if DB is connected
+        if db:
+            try:
+                new_analysis = DBAnalysis(
+                    user_id=request.user_id,
+                    primary_condition=primary,
+                    clinical_scoring=clinical
+                )
+                db.add(new_analysis)
+                db.commit()
+            except Exception as e:
+                print(f"DB save error: {e}")
+
+        return {
+            "primary_condition": primary,
+            "fused_scores": final_scores,
+            "text_scores": text_scores,
+            "survey_scores": survey_scores,
+            "clinical_scoring": clinical,
+            "recommendations": rec
+        }
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+# Flutter-compatible history endpoint
+@app.get("/api/v1/analyses/history")
+async def get_analyses_history(user_id: int = None, db: Session = Depends(get_db)):
+    try:
+        if not db:
+            return []
+
+        query = db.query(DBAnalysis)
+
+        # Filter by user_id if provided
+        if user_id is not None:
+            query = query.filter(DBAnalysis.user_id == user_id)
+
+        # Get the 10 most recent analyses, sorted by created_at ascending (oldest first for graphing)
+        records = query.order_by(DBAnalysis.created_at.desc()).limit(10).all()
+
+        history = []
+        for r in reversed(records):  # Reverse so oldest is first
+            if r.clinical_scoring:
+                history.append({
+                    "id": r.id,
+                    "date": r.created_at.strftime("%b %d"),
+                    "depression": r.clinical_scoring.get("depression", {}).get("score", 0),
+                    "anxiety": r.clinical_scoring.get("anxiety", {}).get("score", 0),
+                    "stress": r.clinical_scoring.get("stress", {}).get("score", 0),
+                    "primary": r.primary_condition
+                })
+        return history
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/api/v1/chat", response_model=ChatResponse)
+async def chat_with_ai(request: ChatRequest):
+    api_url = os.environ.get("AI_API_URL")
+    api_key = os.environ.get("AI_API_KEY")
+    chatflow_id = os.environ.get("AI_CHATFLOW_ID")
+
+    if not api_url or not api_key or not chatflow_id:
+        raise HTTPException(status_code=500, detail="AI API credentials are not configured in Secrets.")
+
+    endpoint = f"{api_url}/api/v1/prediction/{chatflow_id}"
+    headers = {"Authorization": f"Bearer {api_key}"}
+    payload = {"question": request.message, "overrideConfig": {"sessionId": request.session_id}}
+
+    async with httpx.AsyncClient() as client:
+        try:
+            response = await client.post(endpoint, json=payload, headers=headers, timeout=30.0)
+            response.raise_for_status()
+            data = response.json()
+            return ChatResponse(reply=data.get("text") or data.get("answer") or str(data))
+        except Exception as e:
+            raise HTTPException(status_code=502, detail=f"Failed to communicate with AI API: {str(e)}")