Upload 29 files

models/chat_session.py

@@ -0,0 +1,84 @@
+from datetime import datetime
+from pathlib import Path
+import json
+import uuid
+
+class ChatSession:
+    def __init__(self, user_name, session_id=None):
+        self.session_id = session_id or str(uuid.uuid4())
+        self.user_name = user_name
+        self.start_time = datetime.now()
+        self.messages = []
+        self.session_data = {
+            "emotion": None,
+            "mental_health_status": None,
+            "topics_discussed": set(),
+            "agents_used": set(),
+            "sentiment_scores": []
+        }
+    
+    def add_message(self, role, content, agent=None, metadata=None):
+        message = {
+            "timestamp": datetime.now().isoformat(),
+            "role": role,
+            "content": content,
+            "agent": agent,
+            "metadata": metadata or {}
+        }
+        self.messages.append(message)
+        
+        if agent and hasattr(self.session_data["agents_used"], 'add'):
+            self.session_data["agents_used"].add(agent)
+    
+    def add_topic(self, topic):
+        """Safely add a topic"""
+        if hasattr(self.session_data["topics_discussed"], 'add'):
+            self.session_data["topics_discussed"].add(topic)
+        else:
+            # If it's a list, convert to set first
+            topics = set(self.session_data.get("topics_discussed", []))
+            topics.add(topic)
+            self.session_data["topics_discussed"] = topics
+    
+    def to_dict(self):
+        return {
+            "session_id": self.session_id,
+            "user_name": self.user_name,
+            "start_time": self.start_time.isoformat(),
+            "end_time": datetime.now().isoformat(),
+            "duration_minutes": (datetime.now() - self.start_time).seconds // 60,
+            "messages": self.messages,
+            "total_messages": len(self.messages),
+            "session_data": {
+                **self.session_data,
+                "topics_discussed": list(self.session_data["topics_discussed"]) if isinstance(self.session_data["topics_discussed"], set) else self.session_data["topics_discussed"],
+                "agents_used": list(self.session_data["agents_used"]) if isinstance(self.session_data["agents_used"], set) else self.session_data["agents_used"]
+            }
+        }
+    
+    @classmethod
+    def from_dict(cls, data, user_name=None):
+        """Create a ChatSession from dictionary data"""
+        session = cls(user_name or data.get('user_name', 'Guest'), data.get('session_id'))
+        session.messages = data.get('messages', [])
+        
+        # Reconstruct session_data with proper types
+        stored_data = data.get('session_data', {})
+        session.session_data = {
+            "emotion": stored_data.get('emotion'),
+            "mental_health_status": stored_data.get('mental_health_status'),
+            "topics_discussed": set(stored_data.get('topics_discussed', [])),
+            "agents_used": set(stored_data.get('agents_used', [])),
+            "sentiment_scores": stored_data.get('sentiment_scores', [])
+        }
+        
+        return session
+    
+    def save(self, directory="chat_sessions"):
+        Path(directory).mkdir(exist_ok=True)
+        filename = f"{directory}/chat_{self.user_name}_{self.start_time.strftime('%Y%m%d_%H%M%S')}_{self.session_id[:8]}.json"
+        
+        with open(filename, 'w') as f:
+            json.dump(self.to_dict(), f, indent=2)
+        
+        return filename

models/user.py

@@ -0,0 +1,43 @@
+from sqlalchemy import create_engine, Column, Integer, String, DateTime, Boolean, Float, Text
+from sqlalchemy.ext.declarative import declarative_base
+from sqlalchemy.orm import sessionmaker
+from werkzeug.security import generate_password_hash, check_password_hash
+from datetime import datetime
+import secrets
+
+Base = declarative_base()
+
+class User(Base):
+    __tablename__ = 'users'
+    
+    id = Column(Integer, primary_key=True)
+    username = Column(String(80), unique=True, nullable=False)
+    email = Column(String(120), unique=True, nullable=False)
+    password_hash = Column(String(255), nullable=False)
+    full_name = Column(String(100))
+    created_at = Column(DateTime, default=datetime.utcnow)
+    last_login = Column(DateTime)
+    is_active = Column(Boolean, default=True)
+    is_verified = Column(Boolean, default=False)
+    
+    # Profile completion status
+    has_completed_initial_survey = Column(Boolean, default=False)
+    initial_survey_date = Column(DateTime)
+    
+    # Session management
+    session_token = Column(String(255))
+    
+    def set_password(self, password):
+        self.password_hash = generate_password_hash(password)
+    
+    def check_password(self, password):
+        return check_password_hash(self.password_hash, password)
+    
+    def generate_session_token(self):
+        self.session_token = secrets.token_urlsafe(32)
+        return self.session_token
+
+# Create database
+engine = create_engine('sqlite:///mental_health_app.db')
+Base.metadata.create_all(engine)
+Session = sessionmaker(bind=engine)

scripts/db/create_article_tables.py

@@ -0,0 +1,20 @@
+from backend.scripts.migration_schemas.resources_models import Base
+from backend.scripts.db.session import engine
+from sqlalchemy import inspect
+
+def create_tables():
+    inspector = inspect(engine)
+    existing_tables = inspector.get_table_names()
+
+    Base.metadata.create_all(bind=engine)
+
+    updated_tables = inspector.get_table_names()
+    new_tables = set(updated_tables) - set(existing_tables)
+
+    if new_tables:
+        print(f"[INFO] Created new article tables: {', '.join(new_tables)}")
+    else:
+        print("[INFO] No new article tables created. All tables already exist.")
+
+if __name__ == "__main__":
+    create_tables()

scripts/db/create_extensions.py

@@ -0,0 +1,10 @@
+from sqlalchemy import text
+from backend.scripts.db.session import engine
+
+def create_vector_extension():
+    with engine.connect() as conn:
+        conn.execute(text("CREATE EXTENSION IF NOT EXISTS vector WITH SCHEMA extensions;"))
+        print("[INFO] 'vector' extension created if not present.")
+
+if __name__ == "__main__":
+    create_vector_extension()

scripts/db/create_user_tables.py

@@ -0,0 +1,21 @@
+from backend.scripts.migration_schemas.user_models import Base
+from backend.scripts.db.session import engine
+from sqlalchemy import inspect
+
+def create_tables():
+    inspector = inspect(engine)
+    existing_tables = inspector.get_table_names()
+
+    # This will create all tables defined on Base.metadata that don't yet exist
+    Base.metadata.create_all(bind=engine)
+
+    updated_tables = inspector.get_table_names()
+    new_tables = set(updated_tables) - set(existing_tables)
+
+    if new_tables:
+        print(f"[INFO] Created new tables: {', '.join(new_tables)}")
+    else:
+        print("[INFO] No new tables created. All tables already exist.")
+
+if __name__ == "__main__":
+    create_tables()

scripts/db/encrypt_passwords.py

@@ -0,0 +1,58 @@
+import os
+import psycopg2
+import bcrypt
+from psycopg2.extras import RealDictCursor
+from dotenv import load_dotenv
+from backend.scripts.db.session import DATABASE_URL
+import traceback
+
+
+def get_db_connection():
+    return psycopg2.connect(DATABASE_URL, cursor_factory=RealDictCursor)
+
+def hash_unencrypted_passwords():
+    conn = cursor = None
+    try:
+        conn = get_db_connection()
+        cursor = conn.cursor()
+
+        # Find rows with non-bcrypt passwords (e.g. not starting with $2)
+        cursor.execute("""
+            SELECT id, user_password 
+            FROM user_profiles 
+            WHERE user_password NOT LIKE '$2%';
+        """)
+        users = cursor.fetchall()
+
+        print(f"Found {len(users)} users with unencrypted passwords.")
+
+        for user in users:
+            user_id = user['id']
+            raw_password = user['user_password']
+
+            # Hash the plaintext password
+            hashed_pw = bcrypt.hashpw(raw_password.encode(), bcrypt.gensalt()).decode()
+
+            # Update the row with the hashed password
+            cursor.execute("""
+                UPDATE user_profiles 
+                SET user_password = %s 
+                WHERE id = %s
+            """, (hashed_pw, user_id))
+
+        conn.commit()
+        print("Password hashing complete.")
+
+    except Exception as e:
+        print("[ERROR]", e)
+        traceback.print_exc()
+        if conn:
+            conn.rollback()
+    finally:
+        if cursor:
+            cursor.close()
+        if conn:
+            conn.close()
+
+if __name__ == "__main__":
+    hash_unencrypted_passwords()

scripts/db/seed_data_helplines_organizations.py

@@ -0,0 +1,123 @@
+import uuid
+import numpy as np
+from sqlalchemy.exc import IntegrityError, SQLAlchemyError
+
+from backend.scripts.db.session import SessionLocal
+from backend.scripts.migration_schemas.resources_models import Resource
+
+def seed_resources():
+    session = SessionLocal()
+
+    resources = [
+        Resource(
+            id=str(uuid.uuid4()),
+            name="Primary Crisis Hotline",
+            phone="1010",
+            operation_hours="24/7",
+            description="Operated by the Bhutan Youth Development Fund (YDF) and the Ministry of Health, this helpline offers support for mental health issues and suicide prevention.",
+            category="mental health",
+            type="helpline",
+            source="bhutanyouth.org",
+            website="https://bhutanyouth.org"
+        ),
+        Resource(
+            id=str(uuid.uuid4()),
+            name="Emergency Line",
+            phone="112",
+            operation_hours="24/7",
+            description="The national emergency number is for immediate assistance and is accessible via mobile and landline.",
+            category="emergency",
+            type="helpline",
+            source="National Emergency Services", 
+            website="moh.gov.bt"
+        ),
+        Resource(
+            id=str(uuid.uuid4()),
+            name="Mental Health Support Line",
+            phone="1098",
+            operation_hours="24/7",
+            description="National helpline for children and vulnerable groups. Provides mental health support.",
+            category="mental health, children",
+            type="helpline",
+            source="National Helpline Directory", 
+        ),
+
+        Resource(
+            id=str(uuid.uuid4()),
+            name="Sherig Counselling Services (MoE)",
+            phone="17861294",
+            operation_hours="Weekdays 9am–5pm",
+            description="Counselling helpline for students and youth, staffed by trained school counselors.",
+            category="youth, education, counseling",
+            source="moe.gov.bt",
+            website="https://sites.google.com/moe.gov.bt/sherigcounsellingservices", 
+            type = "helpline"
+        ),
+
+        Resource(
+            id=str(uuid.uuid4()),
+            name="PEMA (Psychosocial Education and Mental Health Awareness)",
+            phone="1010",
+            website="https://thepema.gov.bt/",
+            description="PEMA is the national nodal agency for mental health promotion and services, offering counselling, crisis intervention, and rehabilitation. They also have a helpline and offer walk-in services.",
+            type="organization"
+        ),
+        Resource(
+            id=str(uuid.uuid4()),
+            name="RENEW (Respect, Educate, Nurture, and Empower Women)",
+            phone="+975 2 332 159",
+            website="https://renew.org.bt/",
+            description="Founded by Her Majesty Gyalyum Sangay Choden Wangchuck in 2004, RENEW is a non-profit organization supporting women.",
+            type="organization"
+        ),
+        Resource(
+            id=str(uuid.uuid4()),
+            name="Jigme Dorji Wangchuck National Referral Hospital",
+            phone="+975 17 32 24 96",
+            website="https://jdwnrh.gov.bt/",
+            description="This hospital has a psychiatric ward, providing specialized mental health services.",
+            type="organization"
+        ),
+
+        Resource(
+            id=str(uuid.uuid4()),
+            name="Bhutan Board for Certified Counselors (BBCC)",
+            description="Accredits and supports professional counselors in Bhutan. Promotes ethical and culturally sensitive counseling.",
+            phone=None,
+            website="https://www.counselingbhutan.com",
+            address="Thimphu",
+            type="organization"
+        ),
+
+        Resource(
+        id=str(uuid.uuid4()),
+        name="Institute of Traditional Medicine Services",
+        description="Provides traditional Bhutanese medical treatments, including mental and spiritual healing.",
+        phone=None,
+        website=None,
+        address="Langjophakha, Thimphu",
+        type="organization"
+        )
+    ]
+
+    try:
+        for resource in resources:
+            session.add(resource)
+        session.commit()
+        print(f"✅ Inserted {len(resources)} resources into DB.")
+    except IntegrityError as e:
+        session.rollback()
+        print(f"⚠️ Duplicate detected, skipping existing entries: {str(e)}")
+    except SQLAlchemyError as e:
+        session.rollback()
+        print(f"❌ Failed to seed: {str(e)}")
+    finally:
+        session.close()
+
+
+def main():
+    seed_resources()
+
+
+if __name__ == "__main__":
+    main()

scripts/db/session.py

@@ -0,0 +1,16 @@
+import os
+from sqlalchemy import create_engine
+from sqlalchemy.orm import sessionmaker
+from dotenv import load_dotenv
+
+load_dotenv() 
+
+DATABASE_URL = (
+    f"postgresql://{os.getenv('DATABASE_USER')}:{os.getenv('DATABASE_PASSWORD')}"
+    f"@{os.getenv('DATABASE_HOST')}:{os.getenv('DATABASE_PORT')}/{os.getenv('DATABASE_NAME')}"
+)
+
+print("Connecting to:", DATABASE_URL)
+
+engine = create_engine(DATABASE_URL, connect_args={"sslmode": "require"})
+SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)

scripts/ingest/upload_articles_from_bucket.py

@@ -0,0 +1,118 @@
+import os
+import io
+import uuid
+import requests
+import tempfile
+
+from dotenv import load_dotenv
+import boto3
+from sqlalchemy.exc import SQLAlchemyError
+
+from backend.app.core.deps import get_config_value, get_embedding_model
+from backend.rag.pdf_parser import extract_text
+from backend.rag.embeddings import generate_embeddings
+from backend.rag.chunker import smart_chunk_text, create_chunk_objects
+from backend.scripts.db.session import SessionLocal
+from backend.scripts.migration_schemas.resources_models import Article, ArticleChunk
+
+load_dotenv()
+
+# === Load ENV ===
+ACCESS_KEY = os.getenv("AWS_ACCESS_KEY_ID")
+SECRET_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+REGION = os.getenv("AWS_REGION")
+ENDPOINT_URL = os.getenv("SUPABASE_STORAGE_ENDPOINT")
+BUCKET_NAME = os.getenv("SUPABASE_BUCKET")
+SUPABASE_STORAGE_URL = os.getenv("SUPABASE_STORAGE_URL")
+
+class SyncUpload:
+    def __init__(self):
+        self.model = get_embedding_model()
+        self.embedding_dim = get_config_value("model.embedding_dim", 384)
+        self.file_list = self.get_articles_supabase()
+        self.current_articles = self.get_current_articles_psql()
+
+    def get_articles_supabase(self):
+        s3 = boto3.client(
+            's3',
+            region_name=REGION,
+            endpoint_url=ENDPOINT_URL,
+            aws_access_key_id=ACCESS_KEY,
+            aws_secret_access_key=SECRET_KEY
+        )
+        response = s3.list_objects_v2(Bucket=BUCKET_NAME)
+        return [obj['Key'] for obj in response.get('Contents', []) if obj['Key'].endswith('.pdf')]
+
+    def get_current_articles_psql(self):
+        session = SessionLocal()
+        try:
+            return [a.title for a in session.query(Article.title).all()]
+        finally:
+            session.close()
+
+    def extract_text_from_bytes(self, pdf_bytesio):
+        with tempfile.NamedTemporaryFile(suffix=".pdf", delete=True) as tmp:
+            tmp.write(pdf_bytesio.read())
+            tmp.flush()
+            return extract_text(tmp.name)
+
+    def create_article_object(self, id, title):
+        return Article(id=id, title=title)
+
+    def file_to_chunks(self, article_filename, doc_id):
+        article_url = f"{SUPABASE_STORAGE_URL}/v1/object/public/pdfs//{article_filename}"
+        print(f"[INFO] Downloading: {article_url}")
+        response = requests.get(article_url)
+        if response.status_code != 200:
+            print(f"[ERROR] Failed to download {article_url}")
+            return None
+
+        try:
+            text = self.extract_text_from_bytes(io.BytesIO(response.content))
+            print(f"[SUCCESS] Extracted {len(text)} characters from '{article_filename}'")
+            raw_chunks = smart_chunk_text(text)
+            chunk_objs = create_chunk_objects(doc_id=doc_id, chunks=raw_chunks)
+            embedded_chunks = generate_embeddings(chunk_objs)
+            return embedded_chunks
+        except Exception as e:
+            print(f"[ERROR] Processing failed for {article_filename}: {e}")
+            return None
+
+    def articles_to_rag(self):
+        session = SessionLocal()
+        for article_file in self.file_list:
+            article_title = article_file.replace(".pdf", "")
+            if article_title in self.current_articles:
+                print(f"[SKIP] Already processed: {article_title}")
+                continue
+
+            doc_id = str(uuid.uuid4())
+            article = self.create_article_object(id=doc_id, title=article_title)
+            chunk_data = self.file_to_chunks(article_file, doc_id)
+
+            if not chunk_data:
+                continue
+
+            try:
+                chunks = [
+                    ArticleChunk(
+                        chunk_id=c["chunk_id"],
+                        doc_id=c["doc_id"],
+                        chunk_text=c["chunk_text"],
+                        embedding=c["embedding"],
+                        keywords=c["keywords"]
+                    ) for c in chunk_data
+                ]
+
+                session.add(article)
+                session.add_all(chunks)
+                session.commit()
+                print(f"[SUCCESS] Uploaded: {article_title} ({len(chunks)} chunks)")
+            except SQLAlchemyError as e:
+                session.rollback()
+                print(f"[ERROR] DB insert failed for {article_title}: {e}")
+            finally:
+                session.close()
+
+if __name__ == "__main__":
+    SyncUpload().articles_to_rag()

scripts/ingest/upload_files_to_bucket.py

@@ -0,0 +1,73 @@
+import os
+import boto3
+from pathlib import Path
+from botocore.exceptions import ClientError
+from tqdm import tqdm
+import sys
+
+AWS_ACCESS_KEY_ID = os.getenv("AWS_ACCESS_KEY_ID")
+AWS_SECRET_ACCESS_KEY = os.getenv("AWS_SECRET_ACCESS_KEY")
+ENDPOINT_URL = os.getenv("SUPABASE_STORAGE_ENDPOINT") 
+BUCKET_NAME = os.getenv("SUPABASE_BUCKET")
+REGION = os.getenv("AWS_REGION")
+
+s3 = boto3.client(
+    "s3",
+    aws_access_key_id=AWS_ACCESS_KEY_ID,
+    aws_secret_access_key=AWS_SECRET_ACCESS_KEY,
+    endpoint_url=ENDPOINT_URL,
+    region_name=REGION
+)
+
+def upload_pdfs(folder_path: str):
+
+    response = s3.list_objects_v2(Bucket=BUCKET_NAME)
+    file_list = [obj['Key'] for obj in response.get('Contents', []) if obj['Key'].endswith('.pdf')]
+
+    folder = Path(folder_path)
+
+    if not folder.exists() or not folder.is_dir():
+        print("❌ Invalid folder path.")
+        return
+
+    pdf_files = list(folder.glob("*.pdf"))
+
+    if not pdf_files:
+        print("Folder exists, but no PDF files were found.")
+        return
+
+    for file_path in tqdm(pdf_files):
+        key = file_path.name
+        print(f"📄 Uploading: {key}")
+
+        if key in file_list:
+            print(f"✅ {key} already exists in the bucket, skipping.")
+            continue
+        else:
+            try:
+                s3.upload_file(
+                    Filename=str(file_path),
+                    Bucket=BUCKET_NAME,
+                    Key=key,
+                    ExtraArgs={"ContentType": "application/pdf"},
+                )
+            except ClientError as e:
+                print(f"❌ Error uploading {key}: {e}")
+
+    print("✅ Upload complete. Run `make sync-bucket` to process the files.")
+
+
+
+def main():
+    if len(sys.argv) > 1:
+        folder = sys.argv[1]
+    else:
+        print("No folder path provided. Using default: backend/data/rag_articles")
+        folder = input("📂 Enter path to folder with PDFs (normally backend/data/rag_articles)): ").strip()
+
+    print(f"Using folder: {folder}")
+    upload_pdfs(folder)
+    # Your existing logic here, using `folder`
+
+if __name__ == "__main__":
+    main()

scripts/migration_schemas/resources_models.py

@@ -0,0 +1,62 @@
+import yaml
+from sqlalchemy import (
+    Column,
+    String,
+    Text,
+    ForeignKey,
+    Date,
+)
+from sqlalchemy.dialects.postgresql import ARRAY
+from sqlalchemy.ext.declarative import declarative_base
+from pgvector.sqlalchemy import Vector
+from sqlalchemy.orm import relationship
+import os
+from backend.app.core.deps import EMBEDDING_DIM as embedding_dim
+from sqlalchemy import UniqueConstraint
+
+Base = declarative_base()
+
+
+class Resource(Base):
+    __tablename__ = "resources"
+
+    id = Column(String, primary_key=True)
+    name = Column(String, nullable=False)
+    description = Column(Text)
+    phone = Column(String)
+    website = Column(String)
+    address = Column(String)
+    operation_hours = Column(String)
+    category = Column(String)  # e.g., "mental_health", "addiction", etc.
+    type = Column(String, nullable=False)  # e.g., "helpline", "organization"
+    source = Column(String)
+
+    __table_args__ = (
+        UniqueConstraint("name", name="uq_resource_name"),
+    )
+
+class Article(Base):
+    __tablename__ = "articles"
+
+    id = Column(String, primary_key=True, unique=True)
+    title = Column(String, nullable=False, unique=True)
+    author = Column(String)
+    source = Column(String)
+    published_date = Column(Date)
+    topic = Column(String)
+
+    chunks = relationship("ArticleChunk", back_populates="article")
+
+class ArticleChunk(Base):
+    __tablename__ = "article_chunks"
+
+    chunk_id = Column(String, primary_key=True, unique=True)
+    doc_id = Column(String, ForeignKey("articles.id"), nullable=False)
+    chunk_text = Column(Text, nullable=False)
+    embedding = Column(Vector(embedding_dim))
+    keywords = Column(Text) 
+
+    article = relationship("Article", back_populates="chunks")                    
+
+  
+  

scripts/migration_schemas/user_models.py

@@ -0,0 +1,54 @@
+from sqlalchemy import (
+    Column,
+    String,
+    Integer,
+    Text,
+    TIMESTAMP,
+    CheckConstraint,
+    ForeignKey,
+    func,
+)
+from sqlalchemy.dialects.postgresql import UUID
+from sqlalchemy.ext.declarative import declarative_base
+import uuid
+
+Base = declarative_base()
+
+class UserProfile(Base):
+    __tablename__ = "user_profiles"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+
+    name = Column(String(100), nullable=False)
+    age = Column(Integer, CheckConstraint("age > 0 AND age <= 150"))
+    
+    gender = Column(String(20), CheckConstraint(
+        "gender IN ('Male', 'Female', 'Non-binary', 'Other', 'Prefer not to say')"
+    ))
+
+    city_region = Column(String(100))
+    profession = Column(String(100))
+
+    marital_status = Column(String(30), CheckConstraint(
+        "marital_status IN ('Single', 'In relationship', 'Married', 'Divorced', 'Widowed', 'Other', 'Prefer not to say')"
+    ))
+
+    previous_mental_diagnosis = Column(Text, default="NA")
+    ethnicity = Column(String(50))
+
+    created_at = Column(TIMESTAMP(timezone=True), server_default=func.now())
+    updated_at = Column(TIMESTAMP(timezone=True), server_default=func.now(), onupdate=func.now())
+
+
+class ConversationHistory(Base):
+    __tablename__ = "conversation_history"
+
+    id = Column(UUID(as_uuid=True), primary_key=True, default=uuid.uuid4)
+
+    user_id = Column(UUID(as_uuid=True), ForeignKey("user_profiles.id", ondelete="CASCADE"), nullable=False)
+
+    message = Column(Text, nullable=False)
+    response = Column(Text, nullable=False)
+
+    timestamp = Column(TIMESTAMP(timezone=True), server_default=func.now())
+