Upload 22 files

AfyaMindSpace/.gitattributes

@@ -0,0 +1,35 @@
+*.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

AfyaMindSpace/.vscode/settings.json

@@ -0,0 +1,5 @@
+{
+    "files.associations": {
+        "plyconfig.json": "jsonc"
+    }
+}

AfyaMindSpace/README.md

@@ -0,0 +1,13 @@
+---
+title: AfyaMindSpace
+emoji: 🏢
+colorFrom: blue
+colorTo: green
+sdk: streamlit
+sdk_version: 1.41.1
+app_file: app.py
+pinned: false
+short_description: AfyaMind Space is a technology-driven mental health platform
+---
+
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

AfyaMindSpace/analytics.py

@@ -0,0 +1,469 @@
+import streamlit as st
+import pandas as pd
+import altair as alt
+from datetime import datetime, timedelta
+import numpy as np
+
+# Function to analyze mood data and provide insights
+def analyze_mood_data(mood_history):
+    if not mood_history:
+        return None
+    
+    # Convert mood history to DataFrame
+    mood_df = pd.DataFrame(mood_history, columns=["timestamp", "mood"])
+    mood_df["date"] = pd.to_datetime(mood_df["timestamp"]).dt.date
+    mood_df["time"] = pd.to_datetime(mood_df["timestamp"]).dt.time
+    mood_df["hour"] = pd.to_datetime(mood_df["timestamp"]).dt.hour
+    mood_df["day_of_week"] = pd.to_datetime(mood_df["timestamp"]).dt.day_name()
+    
+    # Basic statistics
+    total_entries = len(mood_df)
+    unique_days = mood_df["date"].nunique()
+    most_common_mood = mood_df["mood"].value_counts().index[0]
+    mood_counts = mood_df["mood"].value_counts().to_dict()
+    
+    # Time patterns
+    mood_by_hour = mood_df.groupby("hour")["mood"].value_counts().unstack().fillna(0)
+    mood_by_day = mood_df.groupby("day_of_week")["mood"].value_counts().unstack().fillna(0)
+    
+    # Reorder days of week
+    days_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+    if not mood_by_day.empty:
+        mood_by_day = mood_by_day.reindex(days_order)
+    
+    # Mood transitions (how mood changes from one entry to the next)
+    mood_transitions = {}
+    if len(mood_df) > 1:
+        for i in range(len(mood_df) - 1):
+            current_mood = mood_df.iloc[i]["mood"]
+            next_mood = mood_df.iloc[i+1]["mood"]
+            
+            if current_mood not in mood_transitions:
+                mood_transitions[current_mood] = {}
+            
+            if next_mood not in mood_transitions[current_mood]:
+                mood_transitions[current_mood][next_mood] = 0
+            
+            mood_transitions[current_mood][next_mood] += 1
+    
+    # Mood streaks
+    mood_streaks = {}
+    current_streak = 1
+    current_mood = None
+    
+    for mood in mood_df["mood"]:
+        if mood == current_mood:
+            current_streak += 1
+        else:
+            if current_mood is not None:
+                if current_mood not in mood_streaks or current_streak > mood_streaks[current_mood]:
+                    mood_streaks[current_mood] = current_streak
+            
+            current_mood = mood
+            current_streak = 1
+    
+    # Add the last streak
+    if current_mood is not None and (current_mood not in mood_streaks or current_streak > mood_streaks[current_mood]):
+        mood_streaks[current_mood] = current_streak
+    
+    # Recent trends (last 7 days)
+    today = datetime.now().date()
+    one_week_ago = today - timedelta(days=7)
+    recent_df = mood_df[pd.to_datetime(mood_df["date"]) >= pd.Timestamp(one_week_ago)]
+    
+    recent_mood_counts = recent_df["mood"].value_counts().to_dict() if not recent_df.empty else {}
+    recent_most_common = recent_df["mood"].value_counts().index[0] if not recent_df.empty and len(recent_df["mood"].value_counts()) > 0 else None
+    
+    # Calculate mood variability (how much the mood changes)
+    mood_values = {
+        "happy": 5,
+        "calm": 4,
+        "anxious": 3,
+        "sad": 2,
+        "angry": 1
+    }
+    
+    mood_df["mood_value"] = mood_df["mood"].map(mood_values)
+    mood_variability = mood_df["mood_value"].std() if len(mood_df) > 1 else 0
+    
+    # Prepare data for visualization
+    mood_over_time = mood_df[["date", "mood"]].copy()
+    mood_over_time["date"] = pd.to_datetime(mood_over_time["date"])
+    
+    return {
+        "total_entries": total_entries,
+        "unique_days": unique_days,
+        "most_common_mood": most_common_mood,
+        "mood_counts": mood_counts,
+        "mood_by_hour": mood_by_hour,
+        "mood_by_day": mood_by_day,
+        "mood_transitions": mood_transitions,
+        "mood_streaks": mood_streaks,
+        "recent_mood_counts": recent_mood_counts,
+        "recent_most_common": recent_most_common,
+        "mood_variability": mood_variability,
+        "mood_over_time": mood_over_time
+    }
+
+# Function to generate insights based on mood analysis
+def generate_mood_insights(analysis):
+    if not analysis:
+        return []
+    
+    insights = []
+    
+    # Most common mood
+    insights.append(f"Your most common mood is '{analysis['most_common_mood']}'. You've recorded this mood {analysis['mood_counts'].get(analysis['most_common_mood'], 0)} times.")
+    
+    # Recent trends
+    if analysis["recent_most_common"]:
+        if analysis["recent_most_common"] == analysis["most_common_mood"]:
+            insights.append(f"Your mood has been consistent. '{analysis['recent_most_common']}' is your most common mood recently and overall.")
+        else:
+            insights.append(f"Your mood has shifted recently. While your overall most common mood is '{analysis['most_common_mood']}', recently you've been feeling '{analysis['recent_most_common']}' more often.")
+    
+    # Mood variability
+    if analysis["mood_variability"] < 0.5:
+        insights.append("Your mood has been very stable, with little variation.")
+    elif analysis["mood_variability"] < 1.0:
+        insights.append("Your mood shows moderate variation, which is typical.")
+    else:
+        insights.append("Your mood shows significant variation, with frequent changes.")
+    
+    # Time patterns
+    if not analysis["mood_by_hour"].empty:
+        # Find the hour with the most positive moods (happy, calm)
+        # Handle both DataFrame and Series cases
+        positive_moods = analysis["mood_by_hour"].get(["happy", "calm"], pd.Series(0))
+        if not positive_moods.empty:
+            # Check if positive_moods is a Series or DataFrame
+            if isinstance(positive_moods, pd.Series):
+                best_hour = positive_moods.idxmax() if not positive_moods.empty else None
+            else:  # It's a DataFrame
+                best_hour = positive_moods.sum(axis=1).idxmax() if not positive_moods.sum(axis=1).empty else None
+            
+            if best_hour is not None:
+                am_pm = "AM" if best_hour < 12 else "PM"
+                hour_12 = best_hour % 12
+                if hour_12 == 0:
+                    hour_12 = 12
+                insights.append(f"You tend to feel your best around {hour_12} {am_pm}.")
+        
+        # Find the hour with the most negative moods (sad, angry, anxious)
+        negative_moods = analysis["mood_by_hour"].get(["sad", "angry", "anxious"], pd.Series(0))
+        if not negative_moods.empty:
+            # Check if negative_moods is a Series or DataFrame
+            if isinstance(negative_moods, pd.Series):
+                worst_hour = negative_moods.idxmax() if not negative_moods.empty else None
+            else:  # It's a DataFrame
+                worst_hour = negative_moods.sum(axis=1).idxmax() if not negative_moods.sum(axis=1).empty else None
+            
+            if worst_hour is not None:
+                am_pm = "AM" if worst_hour < 12 else "PM"
+                hour_12 = worst_hour % 12
+                if hour_12 == 0:
+                    hour_12 = 12
+                insights.append(f"You tend to experience more challenging emotions around {hour_12} {am_pm}.")
+    
+    # Day of week patterns
+    if not analysis["mood_by_day"].empty:
+        # Find the day with the most positive moods
+        positive_moods = analysis["mood_by_day"].get(["happy", "calm"], pd.Series(0))
+        if not positive_moods.empty:
+            # Check if positive_moods is a Series or DataFrame
+            if isinstance(positive_moods, pd.Series):
+                best_day = positive_moods.idxmax() if not positive_moods.empty else None
+            else:  # It's a DataFrame
+                best_day = positive_moods.sum(axis=1).idxmax() if not positive_moods.sum(axis=1).empty else None
+            
+            if best_day is not None:
+                insights.append(f"{best_day} tends to be your best day of the week emotionally.")
+        
+        # Find the day with the most negative moods
+        negative_moods = analysis["mood_by_day"].get(["sad", "angry", "anxious"], pd.Series(0))
+        if not negative_moods.empty:
+            # Check if negative_moods is a Series or DataFrame
+            if isinstance(negative_moods, pd.Series):
+                worst_day = negative_moods.idxmax() if not negative_moods.empty else None
+            else:  # It's a DataFrame
+                worst_day = negative_moods.sum(axis=1).idxmax() if not negative_moods.sum(axis=1).empty else None
+            
+            if worst_day is not None:
+                insights.append(f"{worst_day} tends to be your most challenging day emotionally.")
+    
+    # Mood transitions
+    if analysis["mood_transitions"]:
+        for mood, transitions in analysis["mood_transitions"].items():
+            most_common_next = max(transitions.items(), key=lambda x: x[1])[0] if transitions else None
+            if most_common_next and most_common_next != mood:
+                insights.append(f"When you feel '{mood}', you most often transition to feeling '{most_common_next}' next.")
+    
+    # Mood streaks
+    if analysis["mood_streaks"]:
+        longest_streak_mood = max(analysis["mood_streaks"].items(), key=lambda x: x[1])[0]
+        longest_streak = analysis["mood_streaks"][longest_streak_mood]
+        if longest_streak > 1:
+            insights.append(f"Your longest mood streak was feeling '{longest_streak_mood}' for {longest_streak} consecutive recordings.")
+    
+    # Consistency in tracking
+    tracking_consistency = (analysis["unique_days"] / 7) * 100 if analysis["unique_days"] <= 7 else 100
+    if tracking_consistency < 50:
+        insights.append("You're tracking your mood occasionally. More consistent tracking will provide better insights.")
+    elif tracking_consistency < 80:
+        insights.append("You're tracking your mood fairly regularly. Keep it up!")
+    else:
+        insights.append("You're very consistent with tracking your mood, which gives you the most accurate insights.")
+    
+    return insights
+
+# Function to recommend actions based on mood analysis
+def recommend_mood_actions(analysis):
+    if not analysis:
+        return {}
+    
+    recommendations = {
+        "happy": [
+            "Maintain your positive state by engaging in activities you enjoy",
+            "Share your positive energy with others through connection",
+            "Practice gratitude to reinforce positive emotions",
+            "Document what contributed to your happiness for future reference"
+        ],
+        "calm": [
+            "Continue mindfulness practices that help maintain this balanced state",
+            "Use this calm state for creative or focused work",
+            "Practice deep breathing to maintain your sense of calm",
+            "Engage in gentle movement like walking or stretching"
+        ],
+        "anxious": [
+            "Try grounding techniques like the 5-4-3-2-1 sensory exercise",
+            "Practice deep breathing or progressive muscle relaxation",
+            "Limit caffeine and other stimulants",
+            "Break large tasks into smaller, manageable steps",
+            "Consider talking to someone you trust about your feelings"
+        ],
+        "sad": [
+            "Engage in light physical activity like walking",
+            "Reach out to a supportive friend or family member",
+            "Practice self-compassion and avoid self-criticism",
+            "Listen to uplifting music or watch a comforting show",
+            "Set small, achievable goals for the day"
+        ],
+        "angry": [
+            "Take a timeout and practice deep breathing",
+            "Engage in physical activity to release tension",
+            "Write down your thoughts to process them",
+            "Use 'I' statements when communicating your feelings",
+            "Practice progressive muscle relaxation to release physical tension"
+        ]
+    }
+    
+    # Determine which recommendations to prioritize based on recent moods
+    prioritized_recommendations = {}
+    
+    if analysis["recent_mood_counts"]:
+        # Sort recent moods by frequency
+        sorted_moods = sorted(analysis["recent_mood_counts"].items(), key=lambda x: x[1], reverse=True)
+        
+        # Add recommendations for the top 2 most frequent moods
+        for mood, count in sorted_moods[:2]:
+            if mood in recommendations:
+                prioritized_recommendations[mood] = recommendations[mood]
+    else:
+        # If no recent data, use overall most common mood
+        most_common = analysis["most_common_mood"]
+        if most_common in recommendations:
+            prioritized_recommendations[most_common] = recommendations[most_common]
+    
+    return prioritized_recommendations
+
+# UI components for mood analytics
+def mood_analytics_page():
+    st.subheader("Mood Analytics & Insights")
+    
+    if not st.session_state.get("mood_history", []):
+        st.warning("No mood data available. Start tracking your mood to see analytics.")
+        return
+    
+    # Analyze mood data
+    analysis = analyze_mood_data(st.session_state.mood_history)
+    
+    if not analysis:
+        st.warning("Not enough mood data to generate analytics.")
+        return
+    
+    # Display basic statistics
+    st.write(f"**Total mood entries:** {analysis['total_entries']}")
+    st.write(f"**Days with mood tracking:** {analysis['unique_days']}")
+    st.write(f"**Most common mood:** {analysis['most_common_mood']}")
+    
+    # Mood distribution chart
+    st.subheader("Mood Distribution")
+    
+    mood_counts_df = pd.DataFrame({
+        "mood": list(analysis["mood_counts"].keys()),
+        "count": list(analysis["mood_counts"].values())
+    })
+    
+    # Define color scale for moods
+    color_scale = {
+        "happy": "#FFD700",  # Gold
+        "calm": "#90EE90",   # Light green
+        "anxious": "#ADD8E6", # Light blue
+        "sad": "#A9A9A9",    # Dark gray
+        "angry": "#FF6347"   # Tomato
+    }
+    
+    chart = alt.Chart(mood_counts_df).mark_bar().encode(
+        x=alt.X("mood:N", title="Mood", sort=list(color_scale.keys())),
+        y=alt.Y("count:Q", title="Frequency"),
+        color=alt.Color("mood:N", scale=alt.Scale(
+            domain=list(color_scale.keys()),
+            range=list(color_scale.values())
+        ))
+    ).properties(
+        title="Overall Mood Distribution",
+        width=600,
+        height=300
+    )
+    
+    st.altair_chart(chart, use_container_width=True)
+    
+    # Mood over time
+    st.subheader("Mood Over Time")
+    
+    # Prepare data for time series chart
+    mood_time_df = analysis["mood_over_time"].copy()
+    
+    # Create a time series chart
+    time_chart = alt.Chart(mood_time_df).mark_line(point=True).encode(
+        x=alt.X("date:T", title="Date"),
+        y=alt.Y("mood:N", title="Mood", sort=list(reversed(list(color_scale.keys())))),
+        color=alt.Color("mood:N", scale=alt.Scale(
+            domain=list(color_scale.keys()),
+            range=list(color_scale.values())
+        ))
+    ).properties(
+        title="Mood Trends Over Time",
+        width=600,
+        height=300
+    )
+    
+    st.altair_chart(time_chart, use_container_width=True)
+    
+    # Mood by time of day
+    st.subheader("Mood Patterns by Time of Day")
+    
+    if not analysis["mood_by_hour"].empty:
+        # Convert the mood by hour data to a format suitable for Altair
+        hour_data = []
+        for hour, moods in analysis["mood_by_hour"].iterrows():
+            for mood, count in moods.items():
+                if count > 0:  # Only include non-zero counts
+                    hour_data.append({
+                        "hour": hour,
+                        "mood": mood,
+                        "count": count
+                    })
+        
+        hour_df = pd.DataFrame(hour_data)
+        
+        if not hour_df.empty:
+            hour_chart = alt.Chart(hour_df).mark_bar().encode(
+                x=alt.X("hour:O", title="Hour of Day"),
+                y=alt.Y("count:Q", title="Frequency"),
+                color=alt.Color("mood:N", scale=alt.Scale(
+                    domain=list(color_scale.keys()),
+                    range=list(color_scale.values())
+                )),
+                tooltip=["hour", "mood", "count"]
+            ).properties(
+                title="Mood Distribution by Hour of Day",
+                width=600,
+                height=300
+            )
+            
+            st.altair_chart(hour_chart, use_container_width=True)
+        else:
+            st.write("Not enough data to show mood patterns by time of day.")
+    else:
+        st.write("Not enough data to show mood patterns by time of day.")
+    
+    # Mood by day of week
+    st.subheader("Mood Patterns by Day of Week")
+    
+    if not analysis["mood_by_day"].empty:
+        # Convert the mood by day data to a format suitable for Altair
+        day_data = []
+        for day, moods in analysis["mood_by_day"].iterrows():
+            for mood, count in moods.items():
+                if count > 0:  # Only include non-zero counts
+                    day_data.append({
+                        "day": day,
+                        "mood": mood,
+                        "count": count
+                    })
+        
+        day_df = pd.DataFrame(day_data)
+        
+        if not day_df.empty:
+            # Define the order of days
+            days_order = ["Monday", "Tuesday", "Wednesday", "Thursday", "Friday", "Saturday", "Sunday"]
+            
+            day_chart = alt.Chart(day_df).mark_bar().encode(
+                x=alt.X("day:N", title="Day of Week", sort=days_order),
+                y=alt.Y("count:Q", title="Frequency"),
+                color=alt.Color("mood:N", scale=alt.Scale(
+                    domain=list(color_scale.keys()),
+                    range=list(color_scale.values())
+                )),
+                tooltip=["day", "mood", "count"]
+            ).properties(
+                title="Mood Distribution by Day of Week",
+                width=600,
+                height=300
+            )
+            
+            st.altair_chart(day_chart, use_container_width=True)
+        else:
+            st.write("Not enough data to show mood patterns by day of week.")
+    else:
+        st.write("Not enough data to show mood patterns by day of week.")
+    
+    # Insights
+    st.subheader("Mood Insights")
+    
+    insights = generate_mood_insights(analysis)
+    
+    for insight in insights:
+        st.markdown(f"- {insight}")
+    
+    # Recommendations
+    st.subheader("Recommended Actions")
+    
+    recommendations = recommend_mood_actions(analysis)
+    
+    if recommendations:
+        for mood, actions in recommendations.items():
+            with st.expander(f"When you're feeling {mood}"):
+                for action in actions:
+                    st.markdown(f"- {action}")
+    else:
+        st.write("Continue tracking your mood to receive personalized recommendations.")
+    
+    # Export data option
+    st.subheader("Export Your Mood Data")
+    
+    if st.button("Export Mood Data as CSV"):
+        # Create a DataFrame from mood history
+        export_df = pd.DataFrame(st.session_state.mood_history, columns=["timestamp", "mood"])
+        
+        # Convert to CSV
+        csv = export_df.to_csv(index=False)
+        
+        # Create a download button
+        st.download_button(
+            label="Download CSV",
+            data=csv,
+            file_name="mood_history.csv",
+            mime="text/csv"
+        )

AfyaMindSpace/app.py

@@ -0,0 +1,685 @@
+import streamlit as st
+from datetime import datetime, timedelta
+import random
+import pandas as pd
+import altair as alt
+
+# Import custom modules
+from auth import auth_page
+from forum import forum_page
+from meditation import meditation_page
+from goals import goals_page
+from analytics import mood_analytics_page
+from chatbox import create_chat_interface
+
+# Set page configuration
+st.set_page_config(
+    page_title="AfyaMind Space",
+    page_icon="🧠",
+    layout="wide",
+    initial_sidebar_state="expanded"
+)
+
+# Custom CSS for better UI
+st.markdown("""
+<style>
+    .main-header {
+        font-size: 2.5rem;
+        color: #4A90E2;
+        text-align: center;
+        margin-bottom: 1rem;
+    }
+    .subheader {
+        font-size: 1.5rem;
+        color: #6C757D;
+        margin-bottom: 1rem;
+    }
+    .resource-card {
+        background-color: #F8F9FA;
+        padding: 1rem;
+        border-radius: 0.5rem;
+        margin-bottom: 1rem;
+        border-left: 4px solid #4A90E2;
+    }
+    .resource-title {
+        font-weight: bold;
+        color: #4A90E2;
+    }
+    .resource-type {
+        color: #6C757D;
+        font-size: 0.8rem;
+    }
+    .action-button {
+        margin-right: 0.5rem;
+    }
+</style>
+""", unsafe_allow_html=True)
+
+# Mock database for user data and resources
+if "mood_history" not in st.session_state:
+    st.session_state.mood_history = []
+
+if "streak" not in st.session_state:
+    st.session_state.streak = 0
+
+if "last_login" not in st.session_state:
+    st.session_state.last_login = None
+
+if "personalized_resources" not in st.session_state:
+    st.session_state.personalized_resources = []
+
+if "saved_resources" not in st.session_state:
+    st.session_state.saved_resources = []
+
+if "liked_resources" not in st.session_state:
+    st.session_state.liked_resources = []
+
+if "comments" not in st.session_state:
+    st.session_state.comments = {}
+
+if "user_name" not in st.session_state:
+    st.session_state.user_name = ""
+
+if "show_comment_input" not in st.session_state:
+    st.session_state.show_comment_input = {}
+
+# Enhanced resources with more detailed information and tags
+resources = {
+    "stress_management": [
+        {
+            "title": "5 Ways to Manage Stress", 
+            "link": "https://example.com/stress-management", 
+            "type": "Article",
+            "description": "Learn practical techniques to manage daily stress and anxiety.",
+            "tags": ["stress", "anxiety", "coping skills"],
+            "difficulty": "Beginner"
+        },
+        {
+            "title": "Mindfulness Techniques", 
+            "link": "https://example.com/mindfulness", 
+            "type": "Video",
+            "description": "A 10-minute guided video on mindfulness practices for stress reduction.",
+            "tags": ["mindfulness", "meditation", "stress"],
+            "difficulty": "Beginner"
+        },
+        {
+            "title": "Stress Relief Tips", 
+            "link": "https://example.com/stress-relief", 
+            "type": "Podcast",
+            "description": "Expert advice on managing stress in school and social situations.",
+            "tags": ["stress", "school", "social anxiety"],
+            "difficulty": "Intermediate"
+        }
+    ],
+    "mindfulness": [
+        {
+            "title": "Introduction to Mindfulness", 
+            "link": "https://example.com/intro-mindfulness", 
+            "type": "Article",
+            "description": "A beginner's guide to mindfulness and its benefits for mental health.",
+            "tags": ["mindfulness", "beginners", "mental health"],
+            "difficulty": "Beginner"
+        },
+        {
+            "title": "Guided Meditation", 
+            "link": "https://example.com/guided-meditation", 
+            "type": "Video",
+            "description": "A 15-minute guided meditation for anxiety and stress relief.",
+            "tags": ["meditation", "anxiety", "relaxation"],
+            "difficulty": "Beginner"
+        },
+        {
+            "title": "Daily Mindfulness Practices", 
+            "link": "https://example.com/daily-mindfulness", 
+            "type": "Podcast",
+            "description": "Simple mindfulness exercises you can incorporate into your daily routine.",
+            "tags": ["mindfulness", "daily practice", "habits"],
+            "difficulty": "Intermediate"
+        }
+    ],
+    "emotional_intelligence": [
+        {
+            "title": "Understanding Emotions", 
+            "link": "https://example.com/understanding-emotions", 
+            "type": "Article",
+            "description": "Learn to identify and understand different emotions and their triggers.",
+            "tags": ["emotions", "self-awareness", "emotional intelligence"],
+            "difficulty": "Beginner"
+        },
+        {
+            "title": "Building Emotional Resilience", 
+            "link": "https://example.com/emotional-resilience", 
+            "type": "Video",
+            "description": "Techniques to build emotional resilience and bounce back from challenges.",
+            "tags": ["resilience", "coping", "emotional strength"],
+            "difficulty": "Intermediate"
+        },
+        {
+            "title": "Emotional Intelligence 101", 
+            "link": "https://example.com/emotional-intelligence", 
+            "type": "Podcast",
+            "description": "An introduction to emotional intelligence and why it matters for teens.",
+            "tags": ["emotional intelligence", "teens", "social skills"],
+            "difficulty": "Beginner"
+        }
+    ],
+    "depression": [
+        {
+            "title": "Understanding Depression in Teens", 
+            "link": "https://example.com/teen-depression", 
+            "type": "Article",
+            "description": "Signs, symptoms, and coping strategies for depression in adolescents.",
+            "tags": ["depression", "teens", "mental health"],
+            "difficulty": "Intermediate"
+        },
+        {
+            "title": "Overcoming Negative Thoughts", 
+            "link": "https://example.com/negative-thoughts", 
+            "type": "Video",
+            "description": "Cognitive techniques to challenge and reframe negative thinking patterns.",
+            "tags": ["cognitive techniques", "negative thoughts", "depression"],
+            "difficulty": "Intermediate"
+        }
+    ],
+    "social_skills": [
+        {
+            "title": "Building Healthy Relationships", 
+            "link": "https://example.com/healthy-relationships", 
+            "type": "Article",
+            "description": "Tips for developing and maintaining healthy friendships and relationships.",
+            "tags": ["relationships", "communication", "social skills"],
+            "difficulty": "Beginner"
+        },
+        {
+            "title": "Effective Communication Skills", 
+            "link": "https://example.com/communication-skills", 
+            "type": "Video",
+            "description": "Learn how to express yourself clearly and listen effectively to others.",
+            "tags": ["communication", "listening", "expression"],
+            "difficulty": "Intermediate"
+        }
+    ]
+}
+
+# Function to toggle comment input visibility
+def toggle_comment_input(resource_title):
+    if resource_title in st.session_state.show_comment_input:
+        st.session_state.show_comment_input[resource_title] = not st.session_state.show_comment_input[resource_title]
+    else:
+        st.session_state.show_comment_input[resource_title] = True
+
+# Function to add comment
+def add_comment(resource_title, comment):
+    if resource_title not in st.session_state.comments:
+        st.session_state.comments[resource_title] = []
+    st.session_state.comments[resource_title].append(comment)
+    st.session_state.show_comment_input[resource_title] = False
+
+# Function to like resource
+def like_resource(resource):
+    if resource not in st.session_state.liked_resources:
+        st.session_state.liked_resources.append(resource)
+
+# Function to bookmark resource
+def bookmark_resource(resource):
+    if resource not in st.session_state.saved_resources:
+        st.session_state.saved_resources.append(resource)
+
+# Function to track mood with improved UI
+def track_mood():
+    st.markdown("<h2 class='subheader'>Track Your Mood</h2>", unsafe_allow_html=True)
+    
+    col1, col2 = st.columns([3, 2])
+    
+    with col1:
+        # Mood tracking with emojis
+        st.write("How are you feeling today?")
+        mood_options = {
+            "😊 Happy": "happy",
+            "😢 Sad": "sad", 
+            "😰 Anxious": "anxious", 
+            "😠 Angry": "angry", 
+            "😌 Calm": "calm"
+        }
+        
+        mood_cols = st.columns(len(mood_options))
+        selected_mood = None
+        
+        for i, (emoji_mood, mood_value) in enumerate(mood_options.items()):
+            with mood_cols[i]:
+                if st.button(emoji_mood, key=f"mood_{mood_value}"):
+                    selected_mood = mood_value
+        
+        if selected_mood:
+            # Check if this is a new day login
+            today = datetime.now().date()
+            if st.session_state.last_login is None or datetime.strptime(st.session_state.last_login, "%Y-%m-%d").date() < today:
+                st.session_state.streak += 1
+                st.session_state.last_login = today.strftime("%Y-%m-%d")
+            
+            # Record the mood
+            st.session_state.mood_history.append((datetime.now().strftime("%Y-%m-%d %H:%M:%S"), selected_mood))
+            st.success(f"Your mood '{selected_mood}' has been recorded. Thank you for sharing!")
+            
+            # Show streak celebration if streak is a multiple of 5
+            if st.session_state.streak > 0 and st.session_state.streak % 5 == 0:
+                st.balloons()
+                st.success(f"🎉 Congratulations! You've maintained a {st.session_state.streak}-day streak of mood tracking!")
+    
+    with col2:
+        # Display mood statistics and streak
+        if st.session_state.mood_history:
+            st.write(f"🔥 Current streak: {st.session_state.streak} days")
+            
+            # Create a mood history dataframe for visualization
+            if len(st.session_state.mood_history) > 0:
+                mood_df = pd.DataFrame(st.session_state.mood_history, columns=["timestamp", "mood"])
+                mood_df["date"] = pd.to_datetime(mood_df["timestamp"]).dt.date
+                
+                # Count moods for the past week
+                today = datetime.now().date()
+                one_week_ago = today - timedelta(days=7)
+                recent_moods = mood_df[pd.to_datetime(mood_df["date"]) >= pd.Timestamp(one_week_ago)]
+                
+                if not recent_moods.empty:
+                    mood_counts = recent_moods["mood"].value_counts().reset_index()
+                    mood_counts.columns = ["mood", "count"]
+                    
+                    # Create a bar chart
+                    chart = alt.Chart(mood_counts).mark_bar().encode(
+                        x=alt.X("mood:N", title="Mood"),
+                        y=alt.Y("count:Q", title="Frequency"),
+                        color=alt.Color("mood:N", scale=alt.Scale(
+                            domain=["happy", "calm", "anxious", "sad", "angry"],
+                            range=["#FFD700", "#90EE90", "#ADD8E6", "#A9A9A9", "#FF6347"]
+                        ))
+                    ).properties(
+                        title="Your Mood Over the Past Week",
+                        width=300,
+                        height=200
+                    )
+                    
+                    st.altair_chart(chart, use_container_width=True)
+                else:
+                    st.info("Track your mood for a week to see mood patterns.")
+        else:
+            st.info("Start tracking your mood to see statistics.")
+
+# Function to provide personalized resources with improved recommendation algorithm
+def recommend_resources():
+    st.markdown("<h2 class='subheader'>Personalized Resources</h2>", unsafe_allow_html=True)
+    
+    if not st.session_state.mood_history:
+        st.warning("No mood data available. Please track your mood first.")
+        return
+
+    # Get the latest mood and the mood history
+    latest_mood = st.session_state.mood_history[-1][1]
+    
+    # Create a more sophisticated recommendation algorithm
+    # Count mood frequencies from the last 5 entries
+    recent_moods = [mood for _, mood in st.session_state.mood_history[-5:]]
+    mood_counts = {}
+    for mood in recent_moods:
+        if mood in mood_counts:
+            mood_counts[mood] += 1
+        else:
+            mood_counts[mood] = 1
+    
+    # Determine primary and secondary mood states
+    primary_mood = max(mood_counts, key=mood_counts.get)
+    
+    # Resource recommendation logic based on mood patterns
+    recommended_categories = []
+    
+    if primary_mood in ["sad", "angry"]:
+        recommended_categories.extend(["stress_management", "emotional_intelligence"])
+        if mood_counts.get("sad", 0) > mood_counts.get("angry", 0):
+            recommended_categories.append("depression")
+    
+    if primary_mood == "anxious":
+        recommended_categories.extend(["mindfulness", "stress_management"])
+    
+    if primary_mood in ["happy", "calm"]:
+        recommended_categories.extend(["mindfulness", "emotional_intelligence"])
+        if "social_skills" in resources:
+            recommended_categories.append("social_skills")
+    
+    # If we have liked resources, factor those in
+    if st.session_state.liked_resources:
+        liked_tags = []
+        for resource in st.session_state.liked_resources:
+            if "tags" in resource:
+                liked_tags.extend(resource["tags"])
+        
+        # Count tag frequencies
+        tag_counts = {}
+        for tag in liked_tags:
+            if tag in tag_counts:
+                tag_counts[tag] += 1
+            else:
+                tag_counts[tag] = 1
+        
+        # Add categories based on liked tags
+        if tag_counts:
+            top_tags = sorted(tag_counts.items(), key=lambda x: x[1], reverse=True)[:2]
+            for tag, _ in top_tags:
+                for category, resource_list in resources.items():
+                    for resource in resource_list:
+                        if "tags" in resource and tag in resource["tags"] and category not in recommended_categories:
+                            recommended_categories.append(category)
+                            break
+    
+    # Ensure we have at least one category
+    if not recommended_categories:
+        recommended_categories = [random.choice(list(resources.keys()))]
+    
+    # Get resources from recommended categories
+    st.session_state.personalized_resources = []
+    for category in recommended_categories:
+        if category in resources:
+            st.session_state.personalized_resources.extend(resources[category])
+    
+    # Limit to 5 resources and shuffle for variety
+    if len(st.session_state.personalized_resources) > 5:
+        st.session_state.personalized_resources = random.sample(st.session_state.personalized_resources, 5)
+    else:
+        random.shuffle(st.session_state.personalized_resources)
+
+    st.markdown("<h3>Here are some resources tailored for you:</h3>", unsafe_allow_html=True)
+    
+    # Display resources in an improved UI
+    for i, resource in enumerate(st.session_state.personalized_resources):
+        with st.container():
+            st.markdown(f"""
+            <div class="resource-card">
+                <div class="resource-title">{resource['title']}</div>
+                <div class="resource-type">{resource['type']}</div>
+            </div>
+            """, unsafe_allow_html=True)
+            
+            st.markdown(f"**[{resource['title']}]({resource['link']})**")
+            st.write(resource.get("description", ""))
+            
+            # Display tags
+            if "tags" in resource:
+                st.write("Tags: " + ", ".join([f"#{tag}" for tag in resource["tags"]]))
+            
+            # Display difficulty
+            if "difficulty" in resource:
+                st.write(f"Difficulty: {resource['difficulty']}")
+            
+            # Like, Comment, Share, and Bookmark buttons in a row
+            col1, col2, col3, col4 = st.columns(4)
+            
+            with col1:
+                liked = any(r.get('title') == resource['title'] for r in st.session_state.liked_resources)
+                like_label = "👍 Liked" if liked else "👍 Like"
+                if st.button(like_label, key=f"like_{i}_{resource['title']}"):
+                    like_resource(resource)
+                    st.experimental_rerun()
+            
+            with col2:
+                if st.button("💬 Comment", key=f"comment_btn_{i}_{resource['title']}"):
+                    toggle_comment_input(resource['title'])
+                    st.experimental_rerun()
+            
+            with col3:
+                if st.button("🔗 Share", key=f"share_{i}_{resource['title']}"):
+                    st.code(f"{resource['link']}", language="text")
+            
+            with col4:
+                saved = any(r.get('title') == resource['title'] for r in st.session_state.saved_resources)
+                save_label = "🔖 Saved" if saved else "🔖 Save"
+                if st.button(save_label, key=f"save_{i}_{resource['title']}"):
+                    bookmark_resource(resource)
+                    st.experimental_rerun()
+            
+            # Show comment input if toggled
+            if resource['title'] in st.session_state.show_comment_input and st.session_state.show_comment_input[resource['title']]:
+                comment = st.text_area(f"Add a comment for {resource['title']}:", key=f"comment_text_{i}_{resource['title']}")
+                if st.button("Submit Comment", key=f"submit_comment_{i}_{resource['title']}"):
+                    if comment:
+                        add_comment(resource['title'], comment)
+                        st.success("Comment added!")
+                        st.experimental_rerun()
+            
+            # Show existing comments
+            if resource['title'] in st.session_state.comments and st.session_state.comments[resource['title']]:
+                with st.expander(f"View {len(st.session_state.comments[resource['title']])} comments"):
+                    for comment in st.session_state.comments[resource['title']]:
+                        st.write(f"- {comment}")
+            
+            st.markdown("---")
+
+# Function to display user profile with improved UI
+def user_profile():
+    st.markdown("<h2 class='subheader'>Your Profile</h2>", unsafe_allow_html=True)
+    
+    # User name input
+    if not st.session_state.user_name:
+        user_name = st.text_input("What should we call you?")
+        if user_name:
+            st.session_state.user_name = user_name
+            st.success(f"Welcome, {user_name}!")
+            st.experimental_rerun()
+    else:
+        st.write(f"Welcome back, {st.session_state.user_name}! 👋")
+        if st.button("Change name"):
+            st.session_state.user_name = ""
+            st.experimental_rerun()
+    
+    # Create tabs for different sections of the profile
+    profile_tab1, profile_tab2, profile_tab3 = st.tabs(["Mood History", "Saved Resources", "Activity"])
+    
+    with profile_tab1:
+        st.subheader("Mood History")
+        if st.session_state.mood_history:
+            # Create a dataframe for visualization
+            mood_df = pd.DataFrame(st.session_state.mood_history, columns=["timestamp", "mood"])
+            mood_df["date"] = pd.to_datetime(mood_df["timestamp"]).dt.date
+            mood_df["time"] = pd.to_datetime(mood_df["timestamp"]).dt.time
+            
+            # Group by date and get the last mood for each day
+            daily_mood = mood_df.sort_values("timestamp").groupby("date").last().reset_index()
+            
+            # Create a calendar heatmap-like visualization
+            if len(daily_mood) > 0:
+                # Create a color mapping for moods
+                color_scale = {
+                    "happy": "#FFD700",  # Gold
+                    "calm": "#90EE90",   # Light green
+                    "anxious": "#ADD8E6", # Light blue
+                    "sad": "#A9A9A9",    # Dark gray
+                    "angry": "#FF6347"   # Tomato
+                }
+                
+                daily_mood["color"] = daily_mood["mood"].map(color_scale)
+                
+                # Create a chart
+                chart = alt.Chart(daily_mood).mark_rect().encode(
+                    x=alt.X('date:T', title='Date', axis=alt.Axis(format='%b %d')),
+                    color=alt.Color('mood:N', scale=alt.Scale(
+                        domain=list(color_scale.keys()),
+                        range=list(color_scale.values())
+                    ))
+                ).properties(
+                    title="Your Mood Calendar",
+                    width=600,
+                    height=100
+                )
+                
+                st.altair_chart(chart, use_container_width=True)
+                
+                # Show a table of recent moods
+                st.subheader("Recent Mood Entries")
+                recent_moods = mood_df.sort_values("timestamp", ascending=False).head(10)
+                for _, row in recent_moods.iterrows():
+                    st.write(f"{row['timestamp']}: {row['mood']}")
+            else:
+                st.write("No mood history available.")
+        else:
+            st.write("No mood history available.")
+
+    with profile_tab2:
+        st.subheader("Saved Resources")
+        if st.session_state.saved_resources:
+            for i, resource in enumerate(st.session_state.saved_resources):
+                with st.container():
+                    st.markdown(f"""
+                    <div class="resource-card">
+                        <div class="resource-title">{resource['title']}</div>
+                        <div class="resource-type">{resource['type']}</div>
+                    </div>
+                    """, unsafe_allow_html=True)
+                    
+                    st.markdown(f"**[{resource['title']}]({resource['link']})**")
+                    
+                    if "description" in resource:
+                        st.write(resource["description"])
+                    
+                    # Remove from saved button
+                    if st.button("❌ Remove", key=f"remove_saved_{i}"):
+                        st.session_state.saved_resources.remove(resource)
+                        st.experimental_rerun()
+                    
+                    st.markdown("---")
+        else:
+            st.write("No saved resources yet.")
+
+    with profile_tab3:
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            st.subheader("Liked Resources")
+            if st.session_state.liked_resources:
+                for resource in st.session_state.liked_resources:
+                    st.markdown(f"**[{resource['title']}]({resource['link']})**")
+            else:
+                st.write("No liked resources yet.")
+        
+        with col2:
+            st.subheader("Your Comments")
+            if st.session_state.comments:
+                for resource_title, comments in st.session_state.comments.items():
+                    with st.expander(f"{resource_title} ({len(comments)} comments)"):
+                        for comment in comments:
+                            st.write(f"- {comment}")
+            else:
+                st.write("No comments yet.")
+
+# About Us section in the sidebar with improved content
+def about_us():
+    st.sidebar.markdown("<h2>About Us</h2>", unsafe_allow_html=True)
+    st.sidebar.write("""
+    **AfyaMind Space** is a technology-driven mental health platform designed to empower adolescents in low-resource settings. 
+    
+    Our mission is to provide accessible, culturally adaptive, and engaging mental health resources to help young people 
+    manage their emotional well-being and build resilience.
+    
+    ### Our Approach
+    - **Personalized Resources**: Get content tailored to your emotional needs
+    - **Mood Tracking**: Monitor your emotional patterns over time
+    - **Community Support**: Connect with peers in a safe environment
+    - **Offline Access**: Access key resources even without internet
+    """)
+
+# FAQs section in the sidebar with improved content
+def faqs():
+    st.sidebar.markdown("<h2>FAQs</h2>", unsafe_allow_html=True)
+    
+    # Create expandable FAQ items
+    with st.sidebar.expander("What is AfyaMind Space?"):
+        st.write("AfyaMind Space is a digital platform offering AI-powered mental health resources, mood tracking, and peer support for adolescents.")
+    
+    with st.sidebar.expander("Is AfyaMind free to use?"):
+        st.write("Yes, AfyaMind is completely free and accessible to all users.")
+    
+    with st.sidebar.expander("How does AfyaMind protect my data?"):
+        st.write("We use strong encryption and comply with global data protection standards to ensure your privacy.")
+    
+    with st.sidebar.expander("Can I use AfyaMind offline?"):
+        st.write("Yes, AfyaMind offers offline features like mood tracking and downloadable resources for users without internet access.")
+    
+    with st.sidebar.expander("How can I get help in a crisis?"):
+        st.write("""
+        If you're experiencing a mental health crisis:
+        - Call your local emergency number
+        - Text a crisis helpline
+        - Reach out to a trusted adult
+        - Visit the nearest hospital emergency room
+        
+        Remember, you're not alone and help is available.
+        """)
+
+# Help resources in the sidebar
+def help_resources():
+    st.sidebar.markdown("<h2>Help Resources</h2>", unsafe_allow_html=True)
+    st.sidebar.write("""
+    ### Crisis Helplines
+    - **Kenya Mental Health Helpline**: 1199 (toll-free)
+    - **Befrienders Kenya**: 0722 178 177
+    
+    ### Online Resources
+    - [Mental Health Kenya](https://mentalhealthkenya.org/)
+    - [Chiromo Hospital Group](https://www.chiromohospital.org/)
+    """)
+
+# Main app layout with improved UI
+def main():
+    st.markdown("<h1 class='main-header'>AfyaMind Space: Your Mental Health Companion</h1>", unsafe_allow_html=True)
+    
+    # Check if user is logged in
+    is_logged_in = auth_page()
+    
+    # Sidebar with About Us, FAQs, and Help Resources
+    about_us()
+    faqs()
+    help_resources()
+
+    # Only show main content if user is logged in or authentication is not required for this section
+    if "require_auth" not in st.session_state:
+        st.session_state.require_auth = True
+    
+    if is_logged_in or not st.session_state.require_auth:
+        # Tabs for different sections with better styling
+        tab1, tab2, tab3, tab4, tab5, tab6, tab7, tab8 = st.tabs(["🌡️ Track Mood", "📊 Analytics", "📚 Resources", "🧘 Meditation", "🎯 Goals", "💬 Community", "👤 Profile", "💬 Chat Assistant"])
+
+        with tab1:
+            track_mood()
+        
+        with tab2:
+            mood_analytics_page()
+
+        with tab3:
+            recommend_resources()
+        
+        with tab4:
+            meditation_page()
+        
+        with tab5:
+            goals_page()
+        
+        with tab6:
+            forum_page()
+
+        with tab7:
+            user_profile()
+            
+        with tab8:
+            create_chat_interface()
+    
+    # Footer
+    st.markdown("---")
+    st.markdown(
+        """
+        <div style="text-align: center; color: #6C757D; font-size: 0.8rem;">
+            &copy; 2025 AfyaMind Space. Made with &hearts; for adolescent mental health.
+        </div>
+        """, 
+        unsafe_allow_html=True
+    )
+
+# Run the app
+if __name__ == "__main__":
+    main()

AfyaMindSpace/auth.py

@@ -0,0 +1,244 @@
+import streamlit as st
+import hashlib
+import json
+import os
+from datetime import datetime
+
+# File to store user data
+USER_DB_FILE = "user_data.json"
+
+# Initialize user database
+def initialize_user_db():
+    if not os.path.exists(USER_DB_FILE):
+        with open(USER_DB_FILE, "w") as f:
+            json.dump({"users": {}}, f)
+        return {"users": {}}
+    
+    try:
+        with open(USER_DB_FILE, "r") as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        # If file is corrupted, create a new one
+        with open(USER_DB_FILE, "w") as f:
+            json.dump({"users": {}}, f)
+        return {"users": {}}
+
+# Save user database
+def save_user_db(db):
+    with open(USER_DB_FILE, "w") as f:
+        json.dump(db, f)
+
+# Hash password
+def hash_password(password):
+    return hashlib.sha256(password.encode()).hexdigest()
+
+# Register new user
+def register_user(username, password, email):
+    db = initialize_user_db()
+    
+    if username in db["users"]:
+        return False, "Username already exists"
+    
+    # Check for email duplicates
+    for user in db["users"].values():
+        if user["email"] == email:
+            return False, "Email already registered"
+    
+    # Create new user
+    db["users"][username] = {
+        "password_hash": hash_password(password),
+        "email": email,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "last_login": None,
+        "profile": {
+            "display_name": username,
+            "bio": "",
+            "preferences": {
+                "notifications": True,
+                "privacy": "public"
+            }
+        }
+    }
+    
+    save_user_db(db)
+    return True, "Registration successful"
+
+# Authenticate user
+def authenticate_user(username, password):
+    db = initialize_user_db()
+    
+    if username not in db["users"]:
+        return False, "Invalid username or password"
+    
+    if db["users"][username]["password_hash"] != hash_password(password):
+        return False, "Invalid username or password"
+    
+    # Update last login
+    db["users"][username]["last_login"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    save_user_db(db)
+    
+    return True, "Login successful"
+
+# Update user profile
+def update_user_profile(username, profile_data):
+    db = initialize_user_db()
+    
+    if username not in db["users"]:
+        return False, "User not found"
+    
+    # Update profile fields
+    for key, value in profile_data.items():
+        if key in db["users"][username]["profile"]:
+            db["users"][username]["profile"][key] = value
+    
+    save_user_db(db)
+    return True, "Profile updated successfully"
+
+# Get user profile
+def get_user_profile(username):
+    db = initialize_user_db()
+    
+    if username not in db["users"]:
+        return None
+    
+    return db["users"][username]["profile"]
+
+# Change password
+def change_password(username, old_password, new_password):
+    db = initialize_user_db()
+    
+    if username not in db["users"]:
+        return False, "User not found"
+    
+    if db["users"][username]["password_hash"] != hash_password(old_password):
+        return False, "Incorrect password"
+    
+    db["users"][username]["password_hash"] = hash_password(new_password)
+    save_user_db(db)
+    
+    return True, "Password changed successfully"
+
+# Reset password (simplified version - in a real app, this would involve email verification)
+def reset_password(email):
+    db = initialize_user_db()
+    
+    # Find user with this email
+    username = None
+    for user, data in db["users"].items():
+        if data["email"] == email:
+            username = user
+            break
+    
+    if not username:
+        return False, "Email not found"
+    
+    # In a real app, we would send an email with a reset link
+    # For this demo, we'll just generate a temporary password
+    temp_password = "temp" + datetime.now().strftime("%H%M%S")
+    db["users"][username]["password_hash"] = hash_password(temp_password)
+    save_user_db(db)
+    
+    return True, f"Password reset to: {temp_password}"
+
+# Authentication UI components
+def login_form():
+    st.subheader("Login")
+    
+    username = st.text_input("Username", key="login_username")
+    password = st.text_input("Password", type="password", key="login_password")
+    
+    if st.button("Login", key="login_button"):
+        if username and password:
+            success, message = authenticate_user(username, password)
+            if success:
+                st.session_state.logged_in = True
+                st.session_state.username = username
+                st.success(message)
+                st.rerun()
+            else:
+                st.error(message)
+        else:
+            st.warning("Please enter both username and password")
+
+def register_form():
+    st.subheader("Register")
+    
+    # Add asterisks to indicate required fields
+    username = st.text_input("Username *", key="register_username")
+    email = st.text_input("Email *", key="register_email")
+    password = st.text_input("Password *", type="password", key="register_password")
+    confirm_password = st.text_input("Confirm Password *", type="password", key="confirm_password")
+    
+    # Add a note about required fields
+    st.markdown("<small>* Required fields</small>", unsafe_allow_html=True)
+    
+    if st.button("Register", key="register_button"):
+        # Check each field individually and provide specific feedback
+        missing_fields = []
+        if not username:
+            missing_fields.append("Username")
+        if not email:
+            missing_fields.append("Email")
+        if not password:
+            missing_fields.append("Password")
+        if not confirm_password:
+            missing_fields.append("Confirm Password")
+        
+        if missing_fields:
+            st.error(f"Please fill in the following required fields: {', '.join(missing_fields)}")
+        elif password != confirm_password:
+            st.error("Passwords do not match")
+        else:
+            success, message = register_user(username, password, email)
+            if success:
+                st.success(message)
+                st.info("Please login with your new account")
+            else:
+                st.error(message)
+
+def forgot_password_form():
+    st.subheader("Reset Password")
+    
+    email = st.text_input("Email", key="reset_email")
+    
+    if st.button("Reset Password", key="reset_button"):
+        if email:
+            success, message = reset_password(email)
+            if success:
+                st.success("Password reset successful")
+                st.info(message)
+            else:
+                st.error(message)
+        else:
+            st.warning("Please enter your email")
+
+def logout_user():
+    if st.sidebar.button("Logout"):
+        st.session_state.logged_in = False
+        st.session_state.username = None
+        st.rerun()
+
+def auth_page():
+    if "logged_in" not in st.session_state:
+        st.session_state.logged_in = False
+    
+    if "username" not in st.session_state:
+        st.session_state.username = None
+    
+    if not st.session_state.logged_in:
+        tab1, tab2, tab3 = st.tabs(["Login", "Register", "Forgot Password"])
+        
+        with tab1:
+            login_form()
+        
+        with tab2:
+            register_form()
+        
+        with tab3:
+            forgot_password_form()
+        
+        return False
+    else:
+        # User is logged in
+        logout_user()
+        return True

AfyaMindSpace/chatbox.py

@@ -0,0 +1,193 @@
+import streamlit as st
+import time
+import json
+from datetime import datetime
+
+class ChatMessage:
+    def __init__(self, content, is_user=True, timestamp=None):
+        self.content = content
+        self.is_user = is_user
+        self.timestamp = timestamp or datetime.now()
+        self.feedback = None
+
+    def to_dict(self):
+        return {
+            "content": self.content,
+            "is_user": self.is_user,
+            "timestamp": self.timestamp.isoformat(),
+            "feedback": self.feedback
+        }
+
+    @classmethod
+    def from_dict(cls, data):
+        msg = cls(
+            content=data["content"],
+            is_user=data["is_user"],
+            timestamp=datetime.fromisoformat(data["timestamp"])
+        )
+        msg.feedback = data.get("feedback")
+        return msg
+
+class ChatBox:
+    def __init__(self, user_theme="green", assistant_theme="blue"):
+        self.user_theme = user_theme
+        self.assistant_theme = assistant_theme
+        self.init_session()
+
+    def init_session(self, clear=False):
+        """Initialize or clear the chat session"""
+        if "chat_messages" not in st.session_state or clear:
+            st.session_state.chat_messages = []
+
+    def user_say(self, message):
+        """Add a user message to the chat"""
+        if message and message.strip():
+            st.session_state.chat_messages.append(ChatMessage(message, is_user=True))
+            return True
+        return False
+
+    def ai_say(self, message, streaming=False):
+        """Add an AI message to the chat"""
+        if message and message.strip():
+            st.session_state.chat_messages.append(ChatMessage(message, is_user=False))
+            return True
+        return False
+
+    def update_last_ai_message(self, message, streaming=False):
+        """Update the last AI message in the chat"""
+        for i in range(len(st.session_state.chat_messages) - 1, -1, -1):
+            if not st.session_state.chat_messages[i].is_user:
+                st.session_state.chat_messages[i].content = message
+                return True
+        return False
+
+    def set_feedback(self, message_index, feedback):
+        """Set feedback for a message"""
+        if 0 <= message_index < len(st.session_state.chat_messages):
+            st.session_state.chat_messages[message_index].feedback = feedback
+            return True
+        return False
+
+    def render_message(self, message, index):
+        """Render a single message in the chat"""
+        if message.is_user:
+            with st.chat_message("user", avatar="👤"):
+                st.markdown(message.content)
+        else:
+            with st.chat_message("assistant", avatar="🧠"):
+                st.markdown(message.content)
+                
+                # Add feedback buttons if needed
+                col1, col2, col3 = st.columns([1, 1, 8])
+                if col1.button("👍", key=f"like_{index}"):
+                    self.set_feedback(index, "positive")
+                    st.rerun()
+                if col2.button("👎", key=f"dislike_{index}"):
+                    self.set_feedback(index, "negative")
+                    st.rerun()
+
+    def render_chat(self):
+        """Render the entire chat history"""
+        for i, message in enumerate(st.session_state.chat_messages):
+            self.render_message(message, i)
+
+    def to_json(self):
+        """Export chat history to JSON"""
+        return json.dumps([msg.to_dict() for msg in st.session_state.chat_messages], indent=2)
+
+    def from_json(self, json_str):
+        """Import chat history from JSON"""
+        try:
+            data = json.loads(json_str)
+            st.session_state.chat_messages = [ChatMessage.from_dict(msg) for msg in data]
+            return True
+        except Exception as e:
+            st.error(f"Error loading chat history: {e}")
+            return False
+
+    def clear_history(self):
+        """Clear chat history"""
+        self.init_session(clear=True)
+
+# Mock AI response generator for demonstration
+class MockAI:
+    def __init__(self):
+        self.responses = {
+            "hello": "Hello! How can I help you with your mental health today?",
+            "how are you": "I'm just a program, but I'm here to support you. How are you feeling today?",
+            "feeling sad": "I'm sorry to hear you're feeling sad. Would you like to try a quick mood-lifting exercise or talk about what's bothering you?",
+            "feeling anxious": "Anxiety can be challenging. Have you tried any breathing exercises? Taking slow, deep breaths can help calm your nervous system.",
+            "meditation": "Meditation is a great practice for mental health. We have several guided meditations available in the Meditation tab. Would you like me to recommend one?",
+            "help": "I'm here to support your mental health journey. You can ask me about coping strategies, resources, or just chat about how you're feeling."
+        }
+        self.default_response = "I'm here to support you. Could you tell me more about what's on your mind?"
+
+    def get_response(self, query):
+        """Get a response based on the user query"""
+        query = query.lower()
+        for key, response in self.responses.items():
+            if key in query:
+                return response
+        return self.default_response
+
+    def get_streaming_response(self, query):
+        """Simulate a streaming response"""
+        response = self.get_response(query)
+        words = response.split()
+        result = ""
+        for word in words:
+            result += word + " "
+            yield result
+            time.sleep(0.1)
+
+# Function to create a chat interface
+def create_chat_interface():
+    st.markdown("<h2>Chat with AfyaMind Assistant</h2>", unsafe_allow_html=True)
+    
+    # Initialize chat components
+    if "chatbox" not in st.session_state:
+        st.session_state.chatbox = ChatBox()
+    
+    if "ai" not in st.session_state:
+        st.session_state.ai = MockAI()
+    
+    # Chat settings
+    with st.expander("Chat Settings"):
+        col1, col2 = st.columns(2)
+        streaming = col1.checkbox("Enable streaming responses", value=True)
+        col2.download_button(
+            "Export Chat History",
+            st.session_state.chatbox.to_json(),
+            file_name="afyamind_chat_history.json",
+            mime="application/json"
+        )
+        if st.button("Clear Chat History"):
+            st.session_state.chatbox.clear_history()
+            st.rerun()
+    
+    # Display chat history
+    st.session_state.chatbox.render_chat()
+    
+    # Chat input
+    if prompt := st.chat_input("Type your message here..."):
+        # Add user message
+        st.session_state.chatbox.user_say(prompt)
+        
+        # Generate AI response
+        if streaming:
+            # Initial placeholder for streaming response
+            st.session_state.chatbox.ai_say("Thinking...", streaming=True)
+            st.rerun()
+            
+            # This part will run after the rerun
+            # In a real implementation, you would use a proper streaming API
+            # For now, we'll simulate streaming with our mock AI
+        else:
+            response = st.session_state.ai.get_response(prompt)
+            st.session_state.chatbox.ai_say(response)
+            st.rerun()
+
+# For testing the module independently
+if __name__ == "__main__":
+    st.set_page_config(page_title="AfyaMind Chat", page_icon="🧠")
+    create_chat_interface()

AfyaMindSpace/forum.py

@@ -0,0 +1,563 @@
+import streamlit as st
+import json
+import os
+from datetime import datetime
+
+# File to store forum data
+FORUM_DB_FILE = "forum_data.json"
+
+# Initialize forum database
+def initialize_forum_db():
+    if not os.path.exists(FORUM_DB_FILE):
+        forum_data = {
+            "categories": [
+                {
+                    "id": "general",
+                    "name": "General Discussion",
+                    "description": "General topics related to mental health and wellbeing"
+                },
+                {
+                    "id": "stress",
+                    "name": "Stress Management",
+                    "description": "Discuss strategies for managing stress and anxiety"
+                },
+                {
+                    "id": "mindfulness",
+                    "name": "Mindfulness & Meditation",
+                    "description": "Share experiences and tips about mindfulness practices"
+                },
+                {
+                    "id": "support",
+                    "name": "Peer Support",
+                    "description": "A safe space to seek support from others"
+                },
+                {
+                    "id": "success",
+                    "name": "Success Stories",
+                    "description": "Share your mental health journey and achievements"
+                }
+            ],
+            "topics": {},
+            "posts": {}
+        }
+        with open(FORUM_DB_FILE, "w") as f:
+            json.dump(forum_data, f)
+        return forum_data
+    
+    try:
+        with open(FORUM_DB_FILE, "r") as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        # If file is corrupted, create a new one
+        forum_data = {
+            "categories": [
+                {
+                    "id": "general",
+                    "name": "General Discussion",
+                    "description": "General topics related to mental health and wellbeing"
+                },
+                {
+                    "id": "stress",
+                    "name": "Stress Management",
+                    "description": "Discuss strategies for managing stress and anxiety"
+                },
+                {
+                    "id": "mindfulness",
+                    "name": "Mindfulness & Meditation",
+                    "description": "Share experiences and tips about mindfulness practices"
+                },
+                {
+                    "id": "support",
+                    "name": "Peer Support",
+                    "description": "A safe space to seek support from others"
+                },
+                {
+                    "id": "success",
+                    "name": "Success Stories",
+                    "description": "Share your mental health journey and achievements"
+                }
+            ],
+            "topics": {},
+            "posts": {}
+        }
+        with open(FORUM_DB_FILE, "w") as f:
+            json.dump(forum_data, f)
+        return forum_data
+
+# Save forum database
+def save_forum_db(db):
+    with open(FORUM_DB_FILE, "w") as f:
+        json.dump(db, f)
+
+# Create a new topic
+def create_topic(category_id, title, content, author):
+    db = initialize_forum_db()
+    
+    # Check if category exists
+    category_exists = False
+    for category in db["categories"]:
+        if category["id"] == category_id:
+            category_exists = True
+            break
+    
+    if not category_exists:
+        return False, "Category does not exist"
+    
+    # Generate a unique topic ID
+    topic_id = f"topic_{len(db['topics']) + 1}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    
+    # Create the topic
+    db["topics"][topic_id] = {
+        "id": topic_id,
+        "category_id": category_id,
+        "title": title,
+        "author": author,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "updated_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "views": 0,
+        "likes": 0,
+        "is_pinned": False,
+        "is_locked": False,
+        "tags": []
+    }
+    
+    # Create the first post in the topic
+    post_id = f"post_{len(db['posts']) + 1}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    db["posts"][post_id] = {
+        "id": post_id,
+        "topic_id": topic_id,
+        "author": author,
+        "content": content,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "updated_at": None,
+        "likes": 0,
+        "is_solution": False,
+        "replies": []
+    }
+    
+    save_forum_db(db)
+    return True, topic_id
+
+# Get all categories
+def get_categories():
+    db = initialize_forum_db()
+    return db["categories"]
+
+# Get topics by category
+def get_topics_by_category(category_id):
+    db = initialize_forum_db()
+    
+    topics = []
+    for topic_id, topic in db["topics"].items():
+        if topic["category_id"] == category_id:
+            topics.append(topic)
+    
+    # Sort topics by pinned status and then by creation date (newest first)
+    topics.sort(key=lambda x: (not x["is_pinned"], x["created_at"]), reverse=True)
+    
+    return topics
+
+# Get topic by ID
+def get_topic(topic_id):
+    db = initialize_forum_db()
+    
+    if topic_id in db["topics"]:
+        # Increment view count
+        db["topics"][topic_id]["views"] += 1
+        save_forum_db(db)
+        return db["topics"][topic_id]
+    
+    return None
+
+# Get posts by topic ID
+def get_posts_by_topic(topic_id):
+    db = initialize_forum_db()
+    
+    posts = []
+    for post_id, post in db["posts"].items():
+        if post["topic_id"] == topic_id:
+            posts.append(post)
+    
+    # Sort posts by creation date
+    posts.sort(key=lambda x: x["created_at"])
+    
+    return posts
+
+# Create a reply to a post
+def create_reply(post_id, content, author):
+    db = initialize_forum_db()
+    
+    if post_id not in db["posts"]:
+        return False, "Post not found"
+    
+    # Generate a unique reply ID
+    reply_id = f"reply_{len(db['posts'][post_id]['replies']) + 1}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    
+    # Add the reply
+    db["posts"][post_id]["replies"].append({
+        "id": reply_id,
+        "author": author,
+        "content": content,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "updated_at": None,
+        "likes": 0
+    })
+    
+    # Update the topic's updated_at timestamp
+    topic_id = db["posts"][post_id]["topic_id"]
+    db["topics"][topic_id]["updated_at"] = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    
+    save_forum_db(db)
+    return True, reply_id
+
+# Like a post
+def like_post(post_id, username):
+    db = initialize_forum_db()
+    
+    if post_id not in db["posts"]:
+        return False, "Post not found"
+    
+    # In a real app, we would track which users liked which posts
+    # For simplicity, we'll just increment the like count
+    db["posts"][post_id]["likes"] += 1
+    
+    save_forum_db(db)
+    return True, "Post liked"
+
+# Like a topic
+def like_topic(topic_id, username):
+    db = initialize_forum_db()
+    
+    if topic_id not in db["topics"]:
+        return False, "Topic not found"
+    
+    # In a real app, we would track which users liked which topics
+    # For simplicity, we'll just increment the like count
+    db["topics"][topic_id]["likes"] += 1
+    
+    save_forum_db(db)
+    return True, "Topic liked"
+
+# Search topics and posts
+def search_forum(query):
+    db = initialize_forum_db()
+    
+    results = {
+        "topics": [],
+        "posts": []
+    }
+    
+    # Search in topics
+    for topic_id, topic in db["topics"].items():
+        if query.lower() in topic["title"].lower():
+            results["topics"].append(topic)
+    
+    # Search in posts
+    for post_id, post in db["posts"].items():
+        if query.lower() in post["content"].lower():
+            # Add the associated topic
+            topic = db["topics"][post["topic_id"]]
+            if topic not in results["topics"]:
+                results["topics"].append(topic)
+            results["posts"].append(post)
+    
+    return results
+
+# Forum UI components
+def forum_categories():
+    st.subheader("Community Forum")
+    st.write("Connect with others, share experiences, and find support in our community forums.")
+    
+    categories = get_categories()
+    
+    # Display categories in a grid
+    cols = st.columns(2)
+    for i, category in enumerate(categories):
+        with cols[i % 2]:
+            with st.container():
+                st.markdown(f"### {category['name']}")
+                st.write(category['description'])
+                if st.button(f"Browse {category['name']}", key=f"browse_{category['id']}"):
+                    st.session_state.forum_view = "topics"
+                    st.session_state.forum_category = category['id']
+                    st.experimental_rerun()
+
+def forum_topics(category_id):
+    db = initialize_forum_db()
+    
+    # Find category name
+    category_name = "Unknown Category"
+    for category in db["categories"]:
+        if category["id"] == category_id:
+            category_name = category["name"]
+            break
+    
+    st.subheader(f"{category_name} - Topics")
+    
+    # Back button
+    if st.button("← Back to Categories"):
+        st.session_state.forum_view = "categories"
+        st.session_state.forum_category = None
+        st.experimental_rerun()
+    
+    # New topic button
+    if st.session_state.get("logged_in", False):
+        if st.button("+ New Topic"):
+            st.session_state.forum_view = "new_topic"
+            st.experimental_rerun()
+    else:
+        st.info("Please log in to create a new topic")
+    
+    # Get topics
+    topics = get_topics_by_category(category_id)
+    
+    if not topics:
+        st.write("No topics in this category yet. Be the first to start a discussion!")
+    else:
+        # Display topics
+        for topic in topics:
+            with st.container():
+                col1, col2, col3 = st.columns([3, 1, 1])
+                
+                with col1:
+                    title = topic["title"]
+                    if topic["is_pinned"]:
+                        title = "📌 " + title
+                    if topic["is_locked"]:
+                        title = "🔒 " + title
+                    
+                    if st.button(title, key=f"topic_{topic['id']}"):
+                        st.session_state.forum_view = "topic"
+                        st.session_state.forum_topic = topic['id']
+                        st.experimental_rerun()
+                
+                with col2:
+                    st.write(f"👁️ {topic['views']} | ❤️ {topic['likes']}")
+                
+                with col3:
+                    st.write(f"by {topic['author']}")
+                    st.write(f"{topic['created_at']}")
+                
+                st.markdown("---")
+
+def new_topic_form(category_id):
+    db = initialize_forum_db()
+    
+    # Find category name
+    category_name = "Unknown Category"
+    for category in db["categories"]:
+        if category["id"] == category_id:
+            category_name = category["name"]
+            break
+    
+    st.subheader(f"New Topic in {category_name}")
+    
+    # Back button
+    if st.button("← Back to Topics"):
+        st.session_state.forum_view = "topics"
+        st.experimental_rerun()
+    
+    # Topic form
+    title = st.text_input("Topic Title")
+    content = st.text_area("Content", height=200)
+    
+    if st.button("Create Topic"):
+        if title and content:
+            success, result = create_topic(
+                category_id, 
+                title, 
+                content, 
+                st.session_state.username
+            )
+            
+            if success:
+                st.success("Topic created successfully!")
+                st.session_state.forum_view = "topic"
+                st.session_state.forum_topic = result
+                st.experimental_rerun()
+            else:
+                st.error(result)
+        else:
+            st.warning("Please fill in both title and content")
+
+def view_topic(topic_id):
+    topic = get_topic(topic_id)
+    
+    if not topic:
+        st.error("Topic not found")
+        if st.button("Back to Categories"):
+            st.session_state.forum_view = "categories"
+            st.session_state.forum_topic = None
+            st.experimental_rerun()
+        return
+    
+    st.subheader(topic["title"])
+    
+    # Back button
+    if st.button("← Back to Topics"):
+        st.session_state.forum_view = "topics"
+        st.session_state.forum_topic = None
+        st.experimental_rerun()
+    
+    # Topic metadata
+    st.write(f"Started by {topic['author']} on {topic['created_at']}")
+    st.write(f"👁️ {topic['views']} views | ❤️ {topic['likes']} likes")
+    
+    # Like button
+    if st.session_state.get("logged_in", False):
+        if st.button("❤️ Like", key="like_topic"):
+            like_topic(topic_id, st.session_state.username)
+            st.experimental_rerun()
+    
+    st.markdown("---")
+    
+    # Get posts
+    posts = get_posts_by_topic(topic_id)
+    
+    # Display posts
+    for post in posts:
+        with st.container():
+            st.write(f"**{post['author']}** - {post['created_at']}")
+            st.write(post["content"])
+            
+            # Like button for post
+            col1, col2 = st.columns([1, 10])
+            with col1:
+                if st.session_state.get("logged_in", False):
+                    if st.button("👍", key=f"like_post_{post['id']}"):
+                        like_post(post['id'], st.session_state.username)
+                        st.experimental_rerun()
+            with col2:
+                st.write(f"{post['likes']} likes")
+            
+            # Reply button
+            if st.session_state.get("logged_in", False) and not topic["is_locked"]:
+                if st.button("Reply", key=f"reply_button_{post['id']}"):
+                    st.session_state.replying_to = post['id']
+                    st.experimental_rerun()
+            
+            # Reply form
+            if st.session_state.get("replying_to") == post['id']:
+                reply_content = st.text_area("Your reply", key=f"reply_{post['id']}", height=100)
+                
+                col1, col2 = st.columns([1, 5])
+                with col1:
+                    if st.button("Submit", key=f"submit_reply_{post['id']}"):
+                        if reply_content:
+                            success, _ = create_reply(
+                                post['id'], 
+                                reply_content, 
+                                st.session_state.username
+                            )
+                            
+                            if success:
+                                st.session_state.replying_to = None
+                                st.experimental_rerun()
+                        else:
+                            st.warning("Please enter a reply")
+                with col2:
+                    if st.button("Cancel", key=f"cancel_reply_{post['id']}"):
+                        st.session_state.replying_to = None
+                        st.experimental_rerun()
+            
+            # Display replies
+            if post["replies"]:
+                with st.expander(f"View {len(post['replies'])} replies"):
+                    for reply in post["replies"]:
+                        st.write(f"**{reply['author']}** - {reply['created_at']}")
+                        st.write(reply["content"])
+                        st.write(f"{reply['likes']} likes")
+                        st.markdown("---")
+            
+            st.markdown("---")
+    
+    # Reply to topic
+    if st.session_state.get("logged_in", False) and not topic["is_locked"]:
+        st.subheader("Add a Reply")
+        reply_content = st.text_area("Your reply", key="main_reply", height=150)
+        
+        if st.button("Post Reply"):
+            if reply_content:
+                # Get the first post (original post)
+                original_post_id = posts[0]["id"] if posts else None
+                
+                if original_post_id:
+                    success, _ = create_reply(
+                        original_post_id, 
+                        reply_content, 
+                        st.session_state.username
+                    )
+                    
+                    if success:
+                        st.success("Reply posted successfully!")
+                        st.experimental_rerun()
+                else:
+                    st.error("Could not find the original post")
+            else:
+                st.warning("Please enter a reply")
+    elif not st.session_state.get("logged_in", False):
+        st.info("Please log in to reply")
+    elif topic["is_locked"]:
+        st.warning("This topic is locked and cannot be replied to")
+
+def forum_search():
+    st.subheader("Search the Forum")
+    
+    query = st.text_input("Search for topics and posts")
+    
+    if query:
+        results = search_forum(query)
+        
+        if not results["topics"] and not results["posts"]:
+            st.write("No results found")
+        else:
+            st.write(f"Found {len(results['topics'])} topics and {len(results['posts'])} posts")
+            
+            # Display topic results
+            if results["topics"]:
+                st.subheader("Topics")
+                for topic in results["topics"]:
+                    if st.button(topic["title"], key=f"search_topic_{topic['id']}"):
+                        st.session_state.forum_view = "topic"
+                        st.session_state.forum_topic = topic['id']
+                        st.experimental_rerun()
+                    st.write(f"by {topic['author']} on {topic['created_at']}")
+                    st.markdown("---")
+
+def forum_page():
+    # Initialize session state variables if they don't exist
+    if "forum_view" not in st.session_state:
+        st.session_state.forum_view = "categories"
+    
+    if "forum_category" not in st.session_state:
+        st.session_state.forum_category = None
+    
+    if "forum_topic" not in st.session_state:
+        st.session_state.forum_topic = None
+    
+    if "replying_to" not in st.session_state:
+        st.session_state.replying_to = None
+    
+    # Search box in sidebar
+    with st.sidebar:
+        st.subheader("Forum Search")
+        search_query = st.text_input("Search", key="forum_search")
+        if search_query:
+            st.session_state.forum_view = "search"
+            st.experimental_rerun()
+    
+    # Display the appropriate view
+    if st.session_state.forum_view == "categories":
+        forum_categories()
+    elif st.session_state.forum_view == "topics" and st.session_state.forum_category:
+        forum_topics(st.session_state.forum_category)
+    elif st.session_state.forum_view == "topic" and st.session_state.forum_topic:
+        view_topic(st.session_state.forum_topic)
+    elif st.session_state.forum_view == "new_topic" and st.session_state.forum_category:
+        new_topic_form(st.session_state.forum_category)
+    elif st.session_state.forum_view == "search":
+        forum_search()
+    else:
+        # Default to categories view
+        st.session_state.forum_view = "categories"
+        forum_categories()

AfyaMindSpace/forum_data.json

@@ -0,0 +1 @@
+{"categories": [{"id": "general", "name": "General Discussion", "description": "General topics related to mental health and wellbeing"}, {"id": "stress", "name": "Stress Management", "description": "Discuss strategies for managing stress and anxiety"}, {"id": "mindfulness", "name": "Mindfulness & Meditation", "description": "Share experiences and tips about mindfulness practices"}, {"id": "support", "name": "Peer Support", "description": "A safe space to seek support from others"}, {"id": "success", "name": "Success Stories", "description": "Share your mental health journey and achievements"}], "topics": {}, "posts": {}}

AfyaMindSpace/goals.py

@@ -0,0 +1,778 @@
+import streamlit as st
+import json
+import os
+from datetime import datetime, timedelta
+import pandas as pd
+import altair as alt
+
+# File to store goals data
+GOALS_DB_FILE = "goals_data.json"
+
+# Initialize goals database
+def initialize_goals_db():
+    if not os.path.exists(GOALS_DB_FILE):
+        goals_data = {
+            "goals": {},
+            "templates": [
+                {
+                    "id": "stress_reduction",
+                    "title": "Stress Reduction",
+                    "description": "Develop habits to reduce and manage stress in your daily life.",
+                    "suggested_activities": [
+                        "Practice deep breathing for 5 minutes",
+                        "Take a short walk outside",
+                        "Write in a journal",
+                        "Complete a guided meditation",
+                        "Do a body scan relaxation exercise"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Stress Management",
+                    "icon": "🧘"
+                },
+                {
+                    "id": "mood_tracking",
+                    "title": "Consistent Mood Tracking",
+                    "description": "Build a habit of tracking your mood daily to identify patterns.",
+                    "suggested_activities": [
+                        "Record your mood in the morning",
+                        "Record your mood in the evening",
+                        "Note what influenced your mood today",
+                        "Reflect on mood patterns from the past week"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Self-Awareness",
+                    "icon": "📊"
+                },
+                {
+                    "id": "positive_thinking",
+                    "title": "Positive Thinking Practice",
+                    "description": "Train your mind to focus more on positive aspects of life.",
+                    "suggested_activities": [
+                        "Write down three things you're grateful for",
+                        "Give someone a genuine compliment",
+                        "Reframe a negative thought into a positive one",
+                        "Practice positive affirmations",
+                        "Notice and appreciate small joys"
+                    ],
+                    "duration_options": [7, 14, 21],
+                    "category": "Emotional Wellbeing",
+                    "icon": "✨"
+                },
+                {
+                    "id": "social_connection",
+                    "title": "Strengthen Social Connections",
+                    "description": "Build and maintain meaningful social relationships.",
+                    "suggested_activities": [
+                        "Reach out to a friend or family member",
+                        "Have a meaningful conversation with someone",
+                        "Participate in a group activity",
+                        "Practice active listening",
+                        "Express appreciation to someone important to you"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Social Skills",
+                    "icon": "👥"
+                },
+                {
+                    "id": "mindfulness",
+                    "title": "Daily Mindfulness Practice",
+                    "description": "Develop a regular mindfulness practice to stay present and aware.",
+                    "suggested_activities": [
+                        "Practice mindful eating for one meal",
+                        "Do a 5-minute mindfulness meditation",
+                        "Take a mindful walk focusing on your senses",
+                        "Practice mindful breathing for 3 minutes",
+                        "Do a mindful check-in during a stressful moment"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Mindfulness",
+                    "icon": "🌿"
+                },
+                {
+                    "id": "custom",
+                    "title": "Custom Goal",
+                    "description": "Create your own personalized mental health goal.",
+                    "suggested_activities": [],
+                    "duration_options": [7, 14, 21, 30],
+                    "category": "Custom",
+                    "icon": "🎯"
+                }
+            ]
+        }
+        with open(GOALS_DB_FILE, "w") as f:
+            json.dump(goals_data, f)
+        return goals_data
+    
+    try:
+        with open(GOALS_DB_FILE, "r") as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        # If file is corrupted, create a new one
+        goals_data = {
+            "goals": {},
+            "templates": [
+                {
+                    "id": "stress_reduction",
+                    "title": "Stress Reduction",
+                    "description": "Develop habits to reduce and manage stress in your daily life.",
+                    "suggested_activities": [
+                        "Practice deep breathing for 5 minutes",
+                        "Take a short walk outside",
+                        "Write in a journal",
+                        "Complete a guided meditation",
+                        "Do a body scan relaxation exercise"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Stress Management",
+                    "icon": "🧘"
+                },
+                {
+                    "id": "mood_tracking",
+                    "title": "Consistent Mood Tracking",
+                    "description": "Build a habit of tracking your mood daily to identify patterns.",
+                    "suggested_activities": [
+                        "Record your mood in the morning",
+                        "Record your mood in the evening",
+                        "Note what influenced your mood today",
+                        "Reflect on mood patterns from the past week"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Self-Awareness",
+                    "icon": "📊"
+                },
+                {
+                    "id": "positive_thinking",
+                    "title": "Positive Thinking Practice",
+                    "description": "Train your mind to focus more on positive aspects of life.",
+                    "suggested_activities": [
+                        "Write down three things you're grateful for",
+                        "Give someone a genuine compliment",
+                        "Reframe a negative thought into a positive one",
+                        "Practice positive affirmations",
+                        "Notice and appreciate small joys"
+                    ],
+                    "duration_options": [7, 14, 21],
+                    "category": "Emotional Wellbeing",
+                    "icon": "✨"
+                },
+                {
+                    "id": "social_connection",
+                    "title": "Strengthen Social Connections",
+                    "description": "Build and maintain meaningful social relationships.",
+                    "suggested_activities": [
+                        "Reach out to a friend or family member",
+                        "Have a meaningful conversation with someone",
+                        "Participate in a group activity",
+                        "Practice active listening",
+                        "Express appreciation to someone important to you"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Social Skills",
+                    "icon": "👥"
+                },
+                {
+                    "id": "mindfulness",
+                    "title": "Daily Mindfulness Practice",
+                    "description": "Develop a regular mindfulness practice to stay present and aware.",
+                    "suggested_activities": [
+                        "Practice mindful eating for one meal",
+                        "Do a 5-minute mindfulness meditation",
+                        "Take a mindful walk focusing on your senses",
+                        "Practice mindful breathing for 3 minutes",
+                        "Do a mindful check-in during a stressful moment"
+                    ],
+                    "duration_options": [7, 14, 30],
+                    "category": "Mindfulness",
+                    "icon": "🌿"
+                },
+                {
+                    "id": "custom",
+                    "title": "Custom Goal",
+                    "description": "Create your own personalized mental health goal.",
+                    "suggested_activities": [],
+                    "duration_options": [7, 14, 21, 30],
+                    "category": "Custom",
+                    "icon": "🎯"
+                }
+            ]
+        }
+        with open(GOALS_DB_FILE, "w") as f:
+            json.dump(goals_data, f)
+        return goals_data
+
+# Save goals database
+def save_goals_db(db):
+    with open(GOALS_DB_FILE, "w") as f:
+        json.dump(db, f)
+
+# Get all goal templates
+def get_goal_templates():
+    db = initialize_goals_db()
+    return db["templates"]
+
+# Get goal template by ID
+def get_goal_template(template_id):
+    db = initialize_goals_db()
+    
+    for template in db["templates"]:
+        if template["id"] == template_id:
+            return template
+    
+    return None
+
+# Create a new goal for a user
+def create_goal(username, template_id, title, description, activities, duration, start_date=None):
+    if not username:
+        return False, "User not logged in"
+    
+    db = initialize_goals_db()
+    
+    # Generate a unique goal ID
+    goal_id = f"goal_{len(db['goals']) + 1}_{datetime.now().strftime('%Y%m%d%H%M%S')}"
+    
+    # Set start date to today if not provided
+    if not start_date:
+        start_date = datetime.now().strftime("%Y-%m-%d")
+    
+    # Calculate end date
+    start_datetime = datetime.strptime(start_date, "%Y-%m-%d")
+    end_date = (start_datetime + timedelta(days=duration)).strftime("%Y-%m-%d")
+    
+    # Create the goal
+    if username not in db["goals"]:
+        db["goals"][username] = {}
+    
+    db["goals"][username][goal_id] = {
+        "id": goal_id,
+        "template_id": template_id,
+        "title": title,
+        "description": description,
+        "activities": activities,
+        "duration": duration,
+        "start_date": start_date,
+        "end_date": end_date,
+        "progress": {},
+        "completed": False,
+        "created_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S")
+    }
+    
+    save_goals_db(db)
+    return True, goal_id
+
+# Get all goals for a user
+def get_user_goals(username):
+    if not username:
+        return []
+    
+    db = initialize_goals_db()
+    
+    if username not in db["goals"]:
+        return []
+    
+    # Convert to list and sort by creation date (newest first)
+    goals = list(db["goals"][username].values())
+    goals.sort(key=lambda x: x["created_at"], reverse=True)
+    
+    return goals
+
+# Get active goals for a user
+def get_active_goals(username):
+    goals = get_user_goals(username)
+    
+    # Filter for active goals (not completed and end date not passed)
+    today = datetime.now().strftime("%Y-%m-%d")
+    active_goals = [g for g in goals if not g["completed"] and g["end_date"] >= today]
+    
+    return active_goals
+
+# Get a specific goal
+def get_goal(username, goal_id):
+    if not username:
+        return None
+    
+    db = initialize_goals_db()
+    
+    if username not in db["goals"] or goal_id not in db["goals"][username]:
+        return None
+    
+    return db["goals"][username][goal_id]
+
+# Update goal progress
+def update_goal_progress(username, goal_id, activity, completed):
+    if not username:
+        return False, "User not logged in"
+    
+    db = initialize_goals_db()
+    
+    if username not in db["goals"] or goal_id not in db["goals"][username]:
+        return False, "Goal not found"
+    
+    goal = db["goals"][username][goal_id]
+    
+    # Check if activity exists in the goal
+    if activity not in goal["activities"]:
+        return False, "Activity not found in goal"
+    
+    # Get today's date
+    today = datetime.now().strftime("%Y-%m-%d")
+    
+    # Initialize progress for today if needed
+    if today not in goal["progress"]:
+        goal["progress"][today] = []
+    
+    # Update progress
+    if completed and activity not in goal["progress"][today]:
+        goal["progress"][today].append(activity)
+    elif not completed and activity in goal["progress"][today]:
+        goal["progress"][today].remove(activity)
+    
+    save_goals_db(db)
+    return True, "Progress updated"
+
+# Mark goal as completed
+def complete_goal(username, goal_id):
+    if not username:
+        return False, "User not logged in"
+    
+    db = initialize_goals_db()
+    
+    if username not in db["goals"] or goal_id not in db["goals"][username]:
+        return False, "Goal not found"
+    
+    db["goals"][username][goal_id]["completed"] = True
+    
+    save_goals_db(db)
+    return True, "Goal marked as completed"
+
+# Calculate goal statistics
+def calculate_goal_stats(username):
+    goals = get_user_goals(username)
+    
+    if not goals:
+        return {
+            "total": 0,
+            "active": 0,
+            "completed": 0,
+            "expired": 0,
+            "streak": 0,
+            "completion_rate": 0
+        }
+    
+    today = datetime.now().strftime("%Y-%m-%d")
+    yesterday = (datetime.now() - timedelta(days=1)).strftime("%Y-%m-%d")
+    
+    # Count goals by status
+    total = len(goals)
+    completed = sum(1 for g in goals if g["completed"])
+    expired = sum(1 for g in goals if not g["completed"] and g["end_date"] < today)
+    active = total - completed - expired
+    
+    # Calculate completion rate
+    completion_rate = (completed / total) * 100 if total > 0 else 0
+    
+    # Calculate activity streak
+    streak = 0
+    check_date = yesterday
+    had_activity = False
+    
+    while True:
+        # Check if any goal had activity on this date
+        for goal in goals:
+            if check_date in goal["progress"] and goal["progress"][check_date]:
+                had_activity = True
+                break
+        
+        if had_activity:
+            streak += 1
+            # Move to previous day
+            check_date = (datetime.strptime(check_date, "%Y-%m-%d") - timedelta(days=1)).strftime("%Y-%m-%d")
+            had_activity = False
+        else:
+            break
+    
+    return {
+        "total": total,
+        "active": active,
+        "completed": completed,
+        "expired": expired,
+        "streak": streak,
+        "completion_rate": round(completion_rate, 1)
+    }
+
+# Goals UI components
+def goals_dashboard():
+    st.subheader("Your Mental Health Goals")
+    
+    if not st.session_state.get("logged_in", False):
+        st.info("Please log in to set and track your mental health goals")
+        return
+    
+    # Get user goals
+    active_goals = get_active_goals(st.session_state.username)
+    
+    # Stats
+    stats = calculate_goal_stats(st.session_state.username)
+    
+    # Display stats
+    col1, col2, col3, col4 = st.columns(4)
+    
+    with col1:
+        st.metric("Active Goals", stats["active"])
+    
+    with col2:
+        st.metric("Completed", stats["completed"])
+    
+    with col3:
+        st.metric("Activity Streak", f"{stats['streak']} days")
+    
+    with col4:
+        st.metric("Completion Rate", f"{stats['completion_rate']}%")
+    
+    # Create new goal button
+    if st.button("+ Create New Goal"):
+        st.session_state.goals_view = "new_goal"
+        st.experimental_rerun()
+    
+    # Display active goals
+    if not active_goals:
+        st.write("You don't have any active goals. Create one to get started!")
+    else:
+        st.subheader("Active Goals")
+        
+        for goal in active_goals:
+            with st.container():
+                # Calculate days remaining
+                end_date = datetime.strptime(goal["end_date"], "%Y-%m-%d")
+                today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+                days_remaining = (end_date - today).days
+                
+                # Calculate progress percentage
+                total_days = goal["duration"]
+                days_passed = total_days - days_remaining
+                time_progress = min(100, max(0, (days_passed / total_days) * 100))
+                
+                # Calculate activity completion
+                today_str = datetime.now().strftime("%Y-%m-%d")
+                activities_today = goal["progress"].get(today_str, [])
+                activities_completed = len(activities_today)
+                activities_total = len(goal["activities"])
+                activity_progress = (activities_completed / activities_total) * 100 if activities_total > 0 else 0
+                
+                # Display goal card
+                st.markdown(f"### {goal['title']}")
+                st.write(goal["description"])
+                st.write(f"**Days remaining:** {days_remaining} of {goal['duration']}")
+                
+                # Progress bars
+                st.write("**Time progress:**")
+                st.progress(time_progress / 100)
+                
+                st.write(f"**Today's activities:** {activities_completed}/{activities_total}")
+                st.progress(activity_progress / 100)
+                
+                # View details button
+                if st.button("View Details", key=f"view_{goal['id']}"):
+                    st.session_state.goals_view = "view_goal"
+                    st.session_state.current_goal = goal["id"]
+                    st.experimental_rerun()
+                
+                st.markdown("---")
+
+def new_goal_form():
+    st.subheader("Create a New Mental Health Goal")
+    
+    # Back button
+    if st.button("← Back to Dashboard"):
+        st.session_state.goals_view = "dashboard"
+        st.experimental_rerun()
+    
+    # Get templates
+    templates = get_goal_templates()
+    
+    # Step 1: Select template
+    if "goal_step" not in st.session_state:
+        st.session_state.goal_step = 1
+    
+    if "selected_template" not in st.session_state:
+        st.session_state.selected_template = None
+    
+    if st.session_state.goal_step == 1:
+        st.write("Step 1: Select a goal template")
+        
+        # Display templates in a grid
+        cols = st.columns(2)
+        for i, template in enumerate(templates):
+            with cols[i % 2]:
+                with st.container():
+                    st.markdown(f"### {template['icon']} {template['title']}")
+                    st.write(template["description"])
+                    st.write(f"Category: {template['category']}")
+                    
+                    if st.button("Select", key=f"select_{template['id']}"):
+                        st.session_state.selected_template = template["id"]
+                        st.session_state.goal_step = 2
+                        st.experimental_rerun()
+    
+    # Step 2: Customize goal
+    elif st.session_state.goal_step == 2 and st.session_state.selected_template:
+        template = get_goal_template(st.session_state.selected_template)
+        
+        if not template:
+            st.error("Template not found")
+            st.session_state.goal_step = 1
+            st.experimental_rerun()
+            return
+        
+        st.write("Step 2: Customize your goal")
+        
+        # Goal title and description
+        title = st.text_input("Goal Title", value=template["title"])
+        description = st.text_area("Goal Description", value=template["description"])
+        
+        # Duration
+        duration = st.selectbox(
+            "Goal Duration (days)",
+            template["duration_options"],
+            index=0
+        )
+        
+        # Start date
+        start_date = st.date_input(
+            "Start Date",
+            value=datetime.now()
+        ).strftime("%Y-%m-%d")
+        
+        # Activities
+        st.write("Activities to track:")
+        
+        if template["id"] == "custom":
+            # For custom goals, let user add their own activities
+            if "custom_activities" not in st.session_state:
+                st.session_state.custom_activities = [""]
+            
+            for i, activity in enumerate(st.session_state.custom_activities):
+                col1, col2 = st.columns([5, 1])
+                
+                with col1:
+                    st.session_state.custom_activities[i] = st.text_input(
+                        f"Activity {i+1}",
+                        value=activity,
+                        key=f"activity_{i}"
+                    )
+                
+                with col2:
+                    if i > 0 and st.button("Remove", key=f"remove_{i}"):
+                        st.session_state.custom_activities.pop(i)
+                        st.experimental_rerun()
+            
+            if st.button("+ Add Activity"):
+                st.session_state.custom_activities.append("")
+                st.experimental_rerun()
+            
+            activities = [a for a in st.session_state.custom_activities if a.strip()]
+        else:
+            # For predefined templates, let user select from suggested activities
+            activities = []
+            for activity in template["suggested_activities"]:
+                if st.checkbox(activity, value=True):
+                    activities.append(activity)
+            
+            # Option to add custom activities
+            if "additional_activities" not in st.session_state:
+                st.session_state.additional_activities = []
+            
+            st.write("Add your own activities:")
+            
+            if "new_activity" not in st.session_state:
+                st.session_state.new_activity = ""
+            
+            col1, col2 = st.columns([3, 1])
+            
+            with col1:
+                st.session_state.new_activity = st.text_input("New activity")
+            
+            with col2:
+                if st.button("Add") and st.session_state.new_activity.strip():
+                    st.session_state.additional_activities.append(st.session_state.new_activity)
+                    st.session_state.new_activity = ""
+                    st.experimental_rerun()
+            
+            for i, activity in enumerate(st.session_state.additional_activities):
+                col1, col2 = st.columns([5, 1])
+                
+                with col1:
+                    if st.checkbox(activity, value=True, key=f"additional_{i}"):
+                        activities.append(activity)
+                
+                with col2:
+                    if st.button("Remove", key=f"remove_additional_{i}"):
+                        st.session_state.additional_activities.pop(i)
+                        st.experimental_rerun()
+        
+        # Create goal button
+        if st.button("Create Goal"):
+            if title and description and activities:
+                success, goal_id = create_goal(
+                    st.session_state.username,
+                    template["id"],
+                    title,
+                    description,
+                    activities,
+                    duration,
+                    start_date
+                )
+                
+                if success:
+                    st.success("Goal created successfully!")
+                    # Reset session state
+                    st.session_state.goal_step = 1
+                    st.session_state.selected_template = None
+                    if "custom_activities" in st.session_state:
+                        del st.session_state.custom_activities
+                    if "additional_activities" in st.session_state:
+                        del st.session_state.additional_activities
+                    if "new_activity" in st.session_state:
+                        del st.session_state.new_activity
+                    
+                    # Go to view goal
+                    st.session_state.goals_view = "view_goal"
+                    st.session_state.current_goal = goal_id
+                    st.experimental_rerun()
+                else:
+                    st.error(goal_id)  # Error message
+            else:
+                st.warning("Please fill in all required fields and add at least one activity")
+
+def view_goal(goal_id):
+    goal = get_goal(st.session_state.username, goal_id)
+    
+    if not goal:
+        st.error("Goal not found")
+        st.session_state.goals_view = "dashboard"
+        st.experimental_rerun()
+        return
+    
+    # Back button
+    if st.button("← Back to Dashboard"):
+        st.session_state.goals_view = "dashboard"
+        st.experimental_rerun()
+    
+    # Goal details
+    st.subheader(goal["title"])
+    st.write(goal["description"])
+    
+    # Calculate days remaining
+    end_date = datetime.strptime(goal["end_date"], "%Y-%m-%d")
+    today = datetime.now().replace(hour=0, minute=0, second=0, microsecond=0)
+    days_remaining = (end_date - today).days
+    
+    # Display dates and progress
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.write(f"**Start Date:** {goal['start_date']}")
+    
+    with col2:
+        st.write(f"**End Date:** {goal['end_date']}")
+    
+    with col3:
+        if days_remaining > 0:
+            st.write(f"**Days Remaining:** {days_remaining}")
+        else:
+            st.write("**Status:** Ended")
+    
+    # Calculate overall progress
+    total_days = goal["duration"]
+    days_passed = total_days - days_remaining
+    time_progress = min(100, max(0, (days_passed / total_days) * 100))
+    
+    st.write("**Overall Progress:**")
+    st.progress(time_progress / 100)
+    
+    # Today's activities
+    st.subheader("Today's Activities")
+    
+    today_str = datetime.now().strftime("%Y-%m-%d")
+    today_activities = goal["progress"].get(today_str, [])
+    
+    for activity in goal["activities"]:
+        completed = activity in today_activities
+        if st.checkbox(activity, value=completed, key=f"activity_{activity}"):
+            if not completed:
+                update_goal_progress(st.session_state.username, goal_id, activity, True)
+                st.experimental_rerun()
+        else:
+            if completed:
+                update_goal_progress(st.session_state.username, goal_id, activity, False)
+                st.experimental_rerun()
+    
+    # Progress history
+    st.subheader("Progress History")
+    
+    # Create a dataframe for visualization
+    history_data = []
+    
+    start_date = datetime.strptime(goal["start_date"], "%Y-%m-%d")
+    end_date = datetime.strptime(goal["end_date"], "%Y-%m-%d")
+    current_date = min(end_date, datetime.now())
+    
+    date_range = []
+    current = start_date
+    while current <= current_date:
+        date_range.append(current)
+        current += timedelta(days=1)
+    
+    for date in date_range:
+        date_str = date.strftime("%Y-%m-%d")
+        activities_done = len(goal["progress"].get(date_str, []))
+        total_activities = len(goal["activities"])
+        completion_rate = (activities_done / total_activities) * 100 if total_activities > 0 else 0
+        
+        history_data.append({
+            "date": date_str,
+            "completion_rate": completion_rate
+        })
+    
+    if history_data:
+        history_df = pd.DataFrame(history_data)
+        
+        # Create a chart
+        chart = alt.Chart(history_df).mark_bar().encode(
+            x=alt.X('date:T', title='Date'),
+            y=alt.Y('completion_rate:Q', title='Completion Rate (%)')
+        ).properties(
+            title='Daily Activity Completion',
+            width=600,
+            height=200
+        )
+        
+        st.altair_chart(chart, use_container_width=True)
+    else:
+        st.write("No progress data available yet.")
+    
+    # Complete goal button
+    if not goal["completed"] and days_remaining <= 0:
+        if st.button("Mark Goal as Completed"):
+            complete_goal(st.session_state.username, goal_id)
+            st.success("Goal marked as completed!")
+            st.experimental_rerun()
+
+def goals_page():
+    # Initialize session state variables if they don't exist
+    if "goals_view" not in st.session_state:
+        st.session_state.goals_view = "dashboard"
+    
+    if "current_goal" not in st.session_state:
+        st.session_state.current_goal = None
+    
+    # Display the appropriate view
+    if st.session_state.goals_view == "dashboard":
+        goals_dashboard()
+    elif st.session_state.goals_view == "new_goal":
+        new_goal_form()
+    elif st.session_state.goals_view == "view_goal" and st.session_state.current_goal:
+        view_goal(st.session_state.current_goal)
+    else:
+        # Default to dashboard view
+        st.session_state.goals_view = "dashboard"
+        goals_dashboard()

AfyaMindSpace/goals_data.json

@@ -0,0 +1 @@
+{"goals": {}, "templates": [{"id": "stress_reduction", "title": "Stress Reduction", "description": "Develop habits to reduce and manage stress in your daily life.", "suggested_activities": ["Practice deep breathing for 5 minutes", "Take a short walk outside", "Write in a journal", "Complete a guided meditation", "Do a body scan relaxation exercise"], "duration_options": [7, 14, 30], "category": "Stress Management", "icon": "\ud83e\uddd8"}, {"id": "mood_tracking", "title": "Consistent Mood Tracking", "description": "Build a habit of tracking your mood daily to identify patterns.", "suggested_activities": ["Record your mood in the morning", "Record your mood in the evening", "Note what influenced your mood today", "Reflect on mood patterns from the past week"], "duration_options": [7, 14, 30], "category": "Self-Awareness", "icon": "\ud83d\udcca"}, {"id": "positive_thinking", "title": "Positive Thinking Practice", "description": "Train your mind to focus more on positive aspects of life.", "suggested_activities": ["Write down three things you're grateful for", "Give someone a genuine compliment", "Reframe a negative thought into a positive one", "Practice positive affirmations", "Notice and appreciate small joys"], "duration_options": [7, 14, 21], "category": "Emotional Wellbeing", "icon": "\u2728"}, {"id": "social_connection", "title": "Strengthen Social Connections", "description": "Build and maintain meaningful social relationships.", "suggested_activities": ["Reach out to a friend or family member", "Have a meaningful conversation with someone", "Participate in a group activity", "Practice active listening", "Express appreciation to someone important to you"], "duration_options": [7, 14, 30], "category": "Social Skills", "icon": "\ud83d\udc65"}, {"id": "mindfulness", "title": "Daily Mindfulness Practice", "description": "Develop a regular mindfulness practice to stay present and aware.", "suggested_activities": ["Practice mindful eating for one meal", "Do a 5-minute mindfulness meditation", "Take a mindful walk focusing on your senses", "Practice mindful breathing for 3 minutes", "Do a mindful check-in during a stressful moment"], "duration_options": [7, 14, 30], "category": "Mindfulness", "icon": "\ud83c\udf3f"}, {"id": "custom", "title": "Custom Goal", "description": "Create your own personalized mental health goal.", "suggested_activities": [], "duration_options": [7, 14, 21, 30], "category": "Custom", "icon": "\ud83c\udfaf"}]}

AfyaMindSpace/meditation.py

@@ -0,0 +1,563 @@
+import streamlit as st
+import time
+import json
+import os
+from datetime import datetime
+
+# File to store meditation data
+MEDITATION_DB_FILE = "meditation_data.json"
+
+# Initialize meditation database
+def initialize_meditation_db():
+    if not os.path.exists(MEDITATION_DB_FILE):
+        meditation_data = {
+            "sessions": [
+                {
+                    "id": "breathing",
+                    "title": "Deep Breathing Exercise",
+                    "description": "A simple breathing exercise to help calm your mind and reduce stress.",
+                    "duration": 5,
+                    "difficulty": "Beginner",
+                    "category": "Stress Relief",
+                    "steps": [
+                        "Find a comfortable position and close your eyes.",
+                        "Take a deep breath in through your nose for 4 seconds.",
+                        "Hold your breath for 2 seconds.",
+                        "Exhale slowly through your mouth for 6 seconds.",
+                        "Repeat this breathing pattern for the duration of the session."
+                    ],
+                    "background": "#E6F7FF"
+                },
+                {
+                    "id": "body_scan",
+                    "title": "Body Scan Meditation",
+                    "description": "A guided meditation to help you become aware of sensations throughout your body.",
+                    "duration": 10,
+                    "difficulty": "Intermediate",
+                    "category": "Mindfulness",
+                    "steps": [
+                        "Lie down or sit in a comfortable position and close your eyes.",
+                        "Begin by bringing awareness to your breath, noticing the natural rhythm.",
+                        "Slowly shift your attention to your feet, noticing any sensations.",
+                        "Gradually move your awareness up through your legs, torso, arms, and head.",
+                        "If you notice any tension, breathe into that area and allow it to relax.",
+                        "Complete the scan by bringing awareness to your body as a whole."
+                    ],
+                    "background": "#F0E6FF"
+                },
+                {
+                    "id": "gratitude",
+                    "title": "Gratitude Meditation",
+                    "description": "A meditation practice focused on cultivating gratitude and positive emotions.",
+                    "duration": 7,
+                    "difficulty": "Beginner",
+                    "category": "Emotional Wellbeing",
+                    "steps": [
+                        "Sit comfortably with your back straight and eyes closed.",
+                        "Take a few deep breaths to center yourself.",
+                        "Bring to mind something or someone you're grateful for.",
+                        "Notice the feelings of appreciation and warmth that arise.",
+                        "Acknowledge how this person or thing enriches your life.",
+                        "Expand your awareness to include more things you're grateful for.",
+                        "Conclude by setting an intention to notice moments of gratitude throughout your day."
+                    ],
+                    "background": "#FFF0E6"
+                },
+                {
+                    "id": "loving_kindness",
+                    "title": "Loving-Kindness Meditation",
+                    "description": "A practice to develop feelings of goodwill, kindness, and warmth towards others.",
+                    "duration": 12,
+                    "difficulty": "Intermediate",
+                    "category": "Compassion",
+                    "steps": [
+                        "Sit in a comfortable position with your eyes closed.",
+                        "Begin by focusing on your breath, allowing yourself to relax.",
+                        "Bring to mind someone you care about deeply.",
+                        "Silently repeat phrases like 'May you be happy. May you be healthy. May you be safe.'",
+                        "Next, direct these wishes toward yourself: 'May I be happy. May I be healthy. May I be safe.'",
+                        "Gradually extend these wishes to others: acquaintances, difficult people, and all beings.",
+                        "End by taking a few deep breaths and slowly opening your eyes."
+                    ],
+                    "background": "#E6FFE6"
+                },
+                {
+                    "id": "visualization",
+                    "title": "Peaceful Place Visualization",
+                    "description": "A guided visualization to help you relax by imagining a peaceful, safe place.",
+                    "duration": 8,
+                    "difficulty": "Beginner",
+                    "category": "Relaxation",
+                    "steps": [
+                        "Find a comfortable position and close your eyes.",
+                        "Take several deep breaths, allowing your body to relax.",
+                        "Imagine a place where you feel completely peaceful and safe.",
+                        "Notice the details: What do you see? What sounds do you hear?",
+                        "Experience the sensations: What do you feel? What scents are present?",
+                        "Allow yourself to fully immerse in this peaceful place.",
+                        "When ready, slowly bring your awareness back to the present moment."
+                    ],
+                    "background": "#E6FFFF"
+                }
+            ],
+            "user_progress": {}
+        }
+        with open(MEDITATION_DB_FILE, "w") as f:
+            json.dump(meditation_data, f)
+        return meditation_data
+    
+    try:
+        with open(MEDITATION_DB_FILE, "r") as f:
+            return json.load(f)
+    except json.JSONDecodeError:
+        # If file is corrupted, create a new one
+        meditation_data = {
+            "sessions": [
+                {
+                    "id": "breathing",
+                    "title": "Deep Breathing Exercise",
+                    "description": "A simple breathing exercise to help calm your mind and reduce stress.",
+                    "duration": 5,
+                    "difficulty": "Beginner",
+                    "category": "Stress Relief",
+                    "steps": [
+                        "Find a comfortable position and close your eyes.",
+                        "Take a deep breath in through your nose for 4 seconds.",
+                        "Hold your breath for 2 seconds.",
+                        "Exhale slowly through your mouth for 6 seconds.",
+                        "Repeat this breathing pattern for the duration of the session."
+                    ],
+                    "background": "#E6F7FF"
+                },
+                {
+                    "id": "body_scan",
+                    "title": "Body Scan Meditation",
+                    "description": "A guided meditation to help you become aware of sensations throughout your body.",
+                    "duration": 10,
+                    "difficulty": "Intermediate",
+                    "category": "Mindfulness",
+                    "steps": [
+                        "Lie down or sit in a comfortable position and close your eyes.",
+                        "Begin by bringing awareness to your breath, noticing the natural rhythm.",
+                        "Slowly shift your attention to your feet, noticing any sensations.",
+                        "Gradually move your awareness up through your legs, torso, arms, and head.",
+                        "If you notice any tension, breathe into that area and allow it to relax.",
+                        "Complete the scan by bringing awareness to your body as a whole."
+                    ],
+                    "background": "#F0E6FF"
+                },
+                {
+                    "id": "gratitude",
+                    "title": "Gratitude Meditation",
+                    "description": "A meditation practice focused on cultivating gratitude and positive emotions.",
+                    "duration": 7,
+                    "difficulty": "Beginner",
+                    "category": "Emotional Wellbeing",
+                    "steps": [
+                        "Sit comfortably with your back straight and eyes closed.",
+                        "Take a few deep breaths to center yourself.",
+                        "Bring to mind something or someone you're grateful for.",
+                        "Notice the feelings of appreciation and warmth that arise.",
+                        "Acknowledge how this person or thing enriches your life.",
+                        "Expand your awareness to include more things you're grateful for.",
+                        "Conclude by setting an intention to notice moments of gratitude throughout your day."
+                    ],
+                    "background": "#FFF0E6"
+                },
+                {
+                    "id": "loving_kindness",
+                    "title": "Loving-Kindness Meditation",
+                    "description": "A practice to develop feelings of goodwill, kindness, and warmth towards others.",
+                    "duration": 12,
+                    "difficulty": "Intermediate",
+                    "category": "Compassion",
+                    "steps": [
+                        "Sit in a comfortable position with your eyes closed.",
+                        "Begin by focusing on your breath, allowing yourself to relax.",
+                        "Bring to mind someone you care about deeply.",
+                        "Silently repeat phrases like 'May you be happy. May you be healthy. May you be safe.'",
+                        "Next, direct these wishes toward yourself: 'May I be happy. May I be healthy. May I be safe.'",
+                        "Gradually extend these wishes to others: acquaintances, difficult people, and all beings.",
+                        "End by taking a few deep breaths and slowly opening your eyes."
+                    ],
+                    "background": "#E6FFE6"
+                },
+                {
+                    "id": "visualization",
+                    "title": "Peaceful Place Visualization",
+                    "description": "A guided visualization to help you relax by imagining a peaceful, safe place.",
+                    "duration": 8,
+                    "difficulty": "Beginner",
+                    "category": "Relaxation",
+                    "steps": [
+                        "Find a comfortable position and close your eyes.",
+                        "Take several deep breaths, allowing your body to relax.",
+                        "Imagine a place where you feel completely peaceful and safe.",
+                        "Notice the details: What do you see? What sounds do you hear?",
+                        "Experience the sensations: What do you feel? What scents are present?",
+                        "Allow yourself to fully immerse in this peaceful place.",
+                        "When ready, slowly bring your awareness back to the present moment."
+                    ],
+                    "background": "#E6FFFF"
+                }
+            ],
+            "user_progress": {}
+        }
+        with open(MEDITATION_DB_FILE, "w") as f:
+            json.dump(meditation_data, f)
+        return meditation_data
+
+# Save meditation database
+def save_meditation_db(db):
+    with open(MEDITATION_DB_FILE, "w") as f:
+        json.dump(db, f)
+
+# Get all meditation sessions
+def get_meditation_sessions():
+    db = initialize_meditation_db()
+    return db["sessions"]
+
+# Get meditation session by ID
+def get_meditation_session(session_id):
+    db = initialize_meditation_db()
+    
+    for session in db["sessions"]:
+        if session["id"] == session_id:
+            return session
+    
+    return None
+
+# Record completed meditation session
+def record_meditation_completion(username, session_id, duration):
+    if not username:
+        return False, "User not logged in"
+    
+    db = initialize_meditation_db()
+    
+    # Check if session exists
+    session_exists = False
+    for session in db["sessions"]:
+        if session["id"] == session_id:
+            session_exists = True
+            break
+    
+    if not session_exists:
+        return False, "Meditation session not found"
+    
+    # Initialize user progress if needed
+    if username not in db["user_progress"]:
+        db["user_progress"][username] = {
+            "completed_sessions": [],
+            "total_minutes": 0,
+            "streak": 0,
+            "last_completed": None
+        }
+    
+    # Check if this is a new day completion
+    today = datetime.now().strftime("%Y-%m-%d")
+    if db["user_progress"][username]["last_completed"] != today:
+        # Check if the streak should continue or reset
+        if db["user_progress"][username]["last_completed"] is None:
+            db["user_progress"][username]["streak"] = 1
+        else:
+            last_date = datetime.strptime(db["user_progress"][username]["last_completed"], "%Y-%m-%d")
+            today_date = datetime.strptime(today, "%Y-%m-%d")
+            days_diff = (today_date - last_date).days
+            
+            if days_diff == 1:
+                # Consecutive day, increase streak
+                db["user_progress"][username]["streak"] += 1
+            elif days_diff > 1:
+                # Streak broken
+                db["user_progress"][username]["streak"] = 1
+        
+        db["user_progress"][username]["last_completed"] = today
+    
+    # Record the session
+    db["user_progress"][username]["completed_sessions"].append({
+        "session_id": session_id,
+        "completed_at": datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+        "duration": duration
+    })
+    
+    # Update total minutes
+    db["user_progress"][username]["total_minutes"] += duration
+    
+    save_meditation_db(db)
+    return True, "Meditation session recorded"
+
+# Get user meditation stats
+def get_user_meditation_stats(username):
+    if not username:
+        return None
+    
+    db = initialize_meditation_db()
+    
+    if username not in db["user_progress"]:
+        return {
+            "completed_sessions": 0,
+            "total_minutes": 0,
+            "streak": 0,
+            "last_completed": None
+        }
+    
+    stats = db["user_progress"][username]
+    stats["completed_sessions"] = len(stats["completed_sessions"])
+    
+    return stats
+
+# Meditation UI components
+def meditation_library():
+    st.subheader("Guided Meditation Library")
+    st.write("Explore our collection of guided meditations to help you relax, focus, and find peace.")
+    
+    # Get all sessions
+    sessions = get_meditation_sessions()
+    
+    # Filter options
+    col1, col2 = st.columns(2)
+    with col1:
+        difficulty_filter = st.selectbox(
+            "Filter by difficulty",
+            ["All", "Beginner", "Intermediate"],
+            key="difficulty_filter"
+        )
+    
+    with col2:
+        category_filter = st.selectbox(
+            "Filter by category",
+            ["All", "Stress Relief", "Mindfulness", "Emotional Wellbeing", "Compassion", "Relaxation"],
+            key="category_filter"
+        )
+    
+    # Apply filters
+    filtered_sessions = sessions
+    if difficulty_filter != "All":
+        filtered_sessions = [s for s in filtered_sessions if s["difficulty"] == difficulty_filter]
+    
+    if category_filter != "All":
+        filtered_sessions = [s for s in filtered_sessions if s["category"] == category_filter]
+    
+    # Display sessions in a grid
+    if not filtered_sessions:
+        st.write("No meditation sessions match your filters.")
+    else:
+        # Create rows with 2 sessions per row
+        for i in range(0, len(filtered_sessions), 2):
+            cols = st.columns(2)
+            
+            # First session in the row
+            with cols[0]:
+                if i < len(filtered_sessions):
+                    session = filtered_sessions[i]
+                    with st.container():
+                        st.markdown(f"""
+                        <div style="padding: 1rem; border-radius: 0.5rem; background-color: {session['background']}; margin-bottom: 1rem;">
+                            <h3>{session['title']}</h3>
+                            <p><strong>{session['duration']} minutes</strong> | {session['difficulty']} | {session['category']}</p>
+                            <p>{session['description']}</p>
+                        </div>
+                        """, unsafe_allow_html=True)
+                        
+                        if st.button("Start Meditation", key=f"start_{session['id']}"):
+                            st.session_state.meditation_view = "session"
+                            st.session_state.meditation_session = session['id']
+                            st.experimental_rerun()
+            
+            # Second session in the row
+            with cols[1]:
+                if i + 1 < len(filtered_sessions):
+                    session = filtered_sessions[i + 1]
+                    with st.container():
+                        st.markdown(f"""
+                        <div style="padding: 1rem; border-radius: 0.5rem; background-color: {session['background']}; margin-bottom: 1rem;">
+                            <h3>{session['title']}</h3>
+                            <p><strong>{session['duration']} minutes</strong> | {session['difficulty']} | {session['category']}</p>
+                            <p>{session['description']}</p>
+                        </div>
+                        """, unsafe_allow_html=True)
+                        
+                        if st.button("Start Meditation", key=f"start_{session['id']}"):
+                            st.session_state.meditation_view = "session"
+                            st.session_state.meditation_session = session['id']
+                            st.experimental_rerun()
+
+def meditation_session(session_id):
+    session = get_meditation_session(session_id)
+    
+    if not session:
+        st.error("Meditation session not found")
+        if st.button("Back to Library"):
+            st.session_state.meditation_view = "library"
+            st.session_state.meditation_session = None
+            st.experimental_rerun()
+        return
+    
+    st.subheader(session["title"])
+    
+    # Back button
+    if st.button("← Back to Library"):
+        st.session_state.meditation_view = "library"
+        st.session_state.meditation_session = None
+        st.experimental_rerun()
+    
+    # Session details
+    st.write(f"**Duration:** {session['duration']} minutes")
+    st.write(f"**Difficulty:** {session['difficulty']}")
+    st.write(f"**Category:** {session['category']}")
+    st.write(session["description"])
+    
+    # Start meditation button
+    if "meditation_in_progress" not in st.session_state or not st.session_state.meditation_in_progress:
+        if st.button("Begin Meditation"):
+            st.session_state.meditation_in_progress = True
+            st.session_state.meditation_step = 0
+            st.session_state.meditation_start_time = time.time()
+            st.experimental_rerun()
+    else:
+        # Display meditation steps
+        progress = st.progress(0)
+        step_duration = session["duration"] * 60 / len(session["steps"])  # seconds per step
+        
+        # Calculate elapsed time and current step
+        elapsed = time.time() - st.session_state.meditation_start_time
+        total_duration = session["duration"] * 60  # total seconds
+        progress_value = min(elapsed / total_duration, 1.0)
+        progress.progress(progress_value)
+        
+        current_step = min(int(elapsed / step_duration), len(session["steps"]) - 1)
+        
+        # Update step if needed
+        if current_step != st.session_state.meditation_step:
+            st.session_state.meditation_step = current_step
+            st.experimental_rerun()
+        
+        # Display current step
+        st.markdown(f"""
+        <div style="padding: 2rem; border-radius: 0.5rem; background-color: {session['background']}; 
+                 text-align: center; font-size: 1.5rem; margin: 2rem 0;">
+            {session['steps'][current_step]}
+        </div>
+        """, unsafe_allow_html=True)
+        
+        # Time remaining
+        remaining = max(0, total_duration - elapsed)
+        mins = int(remaining // 60)
+        secs = int(remaining % 60)
+        st.write(f"Time remaining: {mins}:{secs:02d}")
+        
+        # End meditation button
+        if st.button("End Meditation Early"):
+            # Record partial completion
+            if st.session_state.get("logged_in", False):
+                actual_duration = min(session["duration"], elapsed / 60)
+                record_meditation_completion(
+                    st.session_state.username,
+                    session_id,
+                    actual_duration
+                )
+            
+            st.session_state.meditation_in_progress = False
+            st.session_state.meditation_step = 0
+            st.experimental_rerun()
+        
+        # Check if meditation is complete
+        if elapsed >= total_duration:
+            # Record completion
+            if st.session_state.get("logged_in", False):
+                record_meditation_completion(
+                    st.session_state.username,
+                    session_id,
+                    session["duration"]
+                )
+            
+            st.success("Meditation complete! Take a moment to notice how you feel.")
+            
+            if st.button("Return to Library"):
+                st.session_state.meditation_in_progress = False
+                st.session_state.meditation_step = 0
+                st.session_state.meditation_view = "library"
+                st.experimental_rerun()
+
+def meditation_stats():
+    if not st.session_state.get("logged_in", False):
+        st.info("Please log in to view your meditation statistics")
+        return
+    
+    stats = get_user_meditation_stats(st.session_state.username)
+    
+    if not stats:
+        st.write("No meditation data available yet. Start your first session!")
+        return
+    
+    # Display stats in a nice UI
+    col1, col2, col3 = st.columns(3)
+    
+    with col1:
+        st.metric("Total Sessions", stats["completed_sessions"])
+    
+    with col2:
+        st.metric("Total Minutes", stats["total_minutes"])
+    
+    with col3:
+        st.metric("Current Streak", f"{stats['streak']} days")
+    
+    # Last meditation
+    if stats["last_completed"]:
+        st.write(f"Last meditation: {stats['last_completed']}")
+    
+    # Achievements
+    if stats["completed_sessions"] > 0:
+        st.subheader("Achievements")
+        
+        achievements = []
+        
+        if stats["completed_sessions"] >= 1:
+            achievements.append("🌱 First Step - Complete your first meditation")
+        
+        if stats["completed_sessions"] >= 5:
+            achievements.append("🌿 Growing Practice - Complete 5 meditations")
+        
+        if stats["completed_sessions"] >= 10:
+            achievements.append("🌳 Established Practice - Complete 10 meditations")
+        
+        if stats["streak"] >= 3:
+            achievements.append("🔥 Momentum - 3 day meditation streak")
+        
+        if stats["streak"] >= 7:
+            achievements.append("⚡ Consistency - 7 day meditation streak")
+        
+        if stats["total_minutes"] >= 60:
+            achievements.append("⏱️ Hour of Peace - Meditate for 60 minutes total")
+        
+        for achievement in achievements:
+            st.markdown(f"**{achievement}**")
+
+def meditation_page():
+    # Initialize session state variables if they don't exist
+    if "meditation_view" not in st.session_state:
+        st.session_state.meditation_view = "library"
+    
+    if "meditation_session" not in st.session_state:
+        st.session_state.meditation_session = None
+    
+    if "meditation_in_progress" not in st.session_state:
+        st.session_state.meditation_in_progress = False
+    
+    if "meditation_step" not in st.session_state:
+        st.session_state.meditation_step = 0
+    
+    # Main content area
+    st.markdown("<h1 style='text-align: center;'>Guided Meditation</h1>", unsafe_allow_html=True)
+    
+    # Tabs for different sections
+    tab1, tab2 = st.tabs(["Meditation Library", "Your Progress"])
+    
+    with tab1:
+        if st.session_state.meditation_view == "library":
+            meditation_library()
+        elif st.session_state.meditation_view == "session" and st.session_state.meditation_session:
+            meditation_session(st.session_state.meditation_session)
+    
+    with tab2:
+        meditation_stats()

AfyaMindSpace/meditation_data.json

@@ -0,0 +1 @@
+{"sessions": [{"id": "breathing", "title": "Deep Breathing Exercise", "description": "A simple breathing exercise to help calm your mind and reduce stress.", "duration": 5, "difficulty": "Beginner", "category": "Stress Relief", "steps": ["Find a comfortable position and close your eyes.", "Take a deep breath in through your nose for 4 seconds.", "Hold your breath for 2 seconds.", "Exhale slowly through your mouth for 6 seconds.", "Repeat this breathing pattern for the duration of the session."], "background": "#E6F7FF"}, {"id": "body_scan", "title": "Body Scan Meditation", "description": "A guided meditation to help you become aware of sensations throughout your body.", "duration": 10, "difficulty": "Intermediate", "category": "Mindfulness", "steps": ["Lie down or sit in a comfortable position and close your eyes.", "Begin by bringing awareness to your breath, noticing the natural rhythm.", "Slowly shift your attention to your feet, noticing any sensations.", "Gradually move your awareness up through your legs, torso, arms, and head.", "If you notice any tension, breathe into that area and allow it to relax.", "Complete the scan by bringing awareness to your body as a whole."], "background": "#F0E6FF"}, {"id": "gratitude", "title": "Gratitude Meditation", "description": "A meditation practice focused on cultivating gratitude and positive emotions.", "duration": 7, "difficulty": "Beginner", "category": "Emotional Wellbeing", "steps": ["Sit comfortably with your back straight and eyes closed.", "Take a few deep breaths to center yourself.", "Bring to mind something or someone you're grateful for.", "Notice the feelings of appreciation and warmth that arise.", "Acknowledge how this person or thing enriches your life.", "Expand your awareness to include more things you're grateful for.", "Conclude by setting an intention to notice moments of gratitude throughout your day."], "background": "#FFF0E6"}, {"id": "loving_kindness", "title": "Loving-Kindness Meditation", "description": "A practice to develop feelings of goodwill, kindness, and warmth towards others.", "duration": 12, "difficulty": "Intermediate", "category": "Compassion", "steps": ["Sit in a comfortable position with your eyes closed.", "Begin by focusing on your breath, allowing yourself to relax.", "Bring to mind someone you care about deeply.", "Silently repeat phrases like 'May you be happy. May you be healthy. May you be safe.'", "Next, direct these wishes toward yourself: 'May I be happy. May I be healthy. May I be safe.'", "Gradually extend these wishes to others: acquaintances, difficult people, and all beings.", "End by taking a few deep breaths and slowly opening your eyes."], "background": "#E6FFE6"}, {"id": "visualization", "title": "Peaceful Place Visualization", "description": "A guided visualization to help you relax by imagining a peaceful, safe place.", "duration": 8, "difficulty": "Beginner", "category": "Relaxation", "steps": ["Find a comfortable position and close your eyes.", "Take several deep breaths, allowing your body to relax.", "Imagine a place where you feel completely peaceful and safe.", "Notice the details: What do you see? What sounds do you hear?", "Experience the sensations: What do you feel? What scents are present?", "Allow yourself to fully immerse in this peaceful place.", "When ready, slowly bring your awareness back to the present moment."], "background": "#E6FFFF"}], "user_progress": {}}

AfyaMindSpace/requirements.txt

@@ -0,0 +1,5 @@
+streamlit==1.41.1
+pandas==2.0.0
+altair==5.0.0
+numpy==1.24.0
+json5==0.9.14

AfyaMindSpace/user_data.json

@@ -0,0 +1 @@
+{"users": {"Jnr": {"password_hash": "79db4572d62ee99cf63284fe62f9a60aae30322515511dd24cff728a8831c507", "email": "iammcqwory@gmail.com", "created_at": "2025-04-01 19:55:29", "last_login": "2025-04-01 20:33:14", "profile": {"display_name": "Jnr", "bio": "", "preferences": {"notifications": true, "privacy": "public"}}}}}