Upload 2 files

app.py

@@ -0,0 +1,453 @@
+import gradio as gr
+import yaml
+import json
+import os
+import traceback
+import matplotlib.pyplot as plt
+import numpy as np
+
+from engine.loader import load_persona
+from engine.drift import apply_context_shift
+from engine.responder import generate_response
+from engine.utils import safe_log
+from engine.logger import log_interaction
+
+# Paths
+persona_dir = "./personas"
+contexts_path = "./contexts/scenarios.json"
+error_log_path = "./ot_simulator_errors.log"
+
+# Load available personas
+def get_persona_choices():
+    return [f for f in os.listdir(persona_dir) if f.endswith(".yml")]
+
+# Load available contextual scenarios
+def get_scenario_choices():
+    try:
+        with open(contexts_path, "r") as f:
+            scenarios = json.load(f)
+        return [s["scenario"] for s in scenarios]
+    except Exception as e:
+        safe_log("Scenarios load error", str(e))
+        return []
+
+# Generate radar chart for emotional/behavioral states
+def plot_state(state, persona_name):
+    if persona_name == "Jack":
+        metrics = ["anxiety", "trust", "openness", "physical_discomfort"]
+        colors = ["#e74c3c", "#3498db", "#2ecc71", "#f39c12"]
+    elif persona_name == "Maya":
+        metrics = ["anxiety", "trust", "creative_engagement", "occupational_balance"]
+        colors = ["#e74c3c", "#3498db", "#9b59b6", "#1abc9c"]
+    else:
+        metrics = ["anxiety", "trust", "openness", "engagement"]
+        colors = ["#e74c3c", "#3498db", "#2ecc71", "#95a5a6"]
+    
+    values = [state.get(m, 0.0) for m in metrics]
+    angles = np.linspace(0, 2 * np.pi, len(metrics), endpoint=False).tolist()
+    values += values[:1]
+    angles += angles[:1]
+
+    fig, ax = plt.subplots(figsize=(5, 5), subplot_kw=dict(polar=True))
+    ax.plot(angles, values, color=colors[0], linewidth=2)
+    ax.fill(angles, values, color=colors[0], alpha=0.25)
+    ax.set_xticks(angles[:-1])
+    ax.set_xticklabels([m.replace('_', ' ').title() for m in metrics])
+    ax.set_ylim(0, 1)
+    ax.set_yticklabels(['0.0', '0.2', '0.4', '0.6', '0.8', '1.0'])
+    ax.set_title(f"{persona_name}'s Emotional State", fontsize=14, pad=20)
+    ax.grid(True)
+    fig.tight_layout()
+
+    chart_path = f"./state_chart_{persona_name}.png"
+    fig.savefig(chart_path, dpi=100, bbox_inches='tight')
+    plt.close(fig)
+    return chart_path
+
+# Generate interaction history visualization
+def plot_interaction_history(history):
+    if not history or len(history) < 2:
+        return None
+    
+    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(8, 6))
+    
+    interactions = list(range(1, len(history) + 1))
+    anxiety_vals = [h.get('anxiety', 0) for h in history]
+    trust_vals = [h.get('trust', 0) for h in history]
+    
+    ax1.plot(interactions, anxiety_vals, marker='o', color='#e74c3c', linewidth=2, label='Anxiety')
+    ax1.set_ylabel('Anxiety Level', fontsize=10)
+    ax1.set_ylim(0, 1)
+    ax1.grid(True, alpha=0.3)
+    ax1.legend(loc='upper right')
+    
+    ax2.plot(interactions, trust_vals, marker='o', color='#3498db', linewidth=2, label='Trust')
+    ax2.set_xlabel('Interaction Number', fontsize=10)
+    ax2.set_ylabel('Trust Level', fontsize=10)
+    ax2.set_ylim(0, 1)
+    ax2.grid(True, alpha=0.3)
+    ax2.legend(loc='upper right')
+    
+    fig.suptitle('Therapeutic Relationship Over Time', fontsize=14)
+    fig.tight_layout()
+    
+    history_path = "./interaction_history.png"
+    fig.savefig(history_path, dpi=100, bbox_inches='tight')
+    plt.close(fig)
+    return history_path
+
+# Download session transcript
+def download_session(conversation_history, state_history, selected_persona_file):
+    """Generate downloadable transcript file."""
+    if not conversation_history:
+        return None
+    
+    try:
+        persona_path = os.path.join(persona_dir, selected_persona_file)
+        persona = load_persona(persona_path)
+        
+        from datetime import datetime
+        timestamp = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
+        name = persona.get("persona_name", "Client")
+        
+        # Create transcript
+        transcript = f"""
+���������������������������������������������������������������
+        OT MENTAL HEALTH SIMULATION - SESSION TRANSCRIPT
+���������������������������������������������������������������
+
+Client: {name}
+Date: {timestamp}
+Number of Interactions: {len(conversation_history)}
+
+���������������������������������������������������������������
+CONVERSATION
+���������������������������������������������������������������
+
+"""
+        
+        for i, turn in enumerate(conversation_history, 1):
+            transcript += f"\n[Turn {i}]\n"
+            if 'scenario' in turn:
+                transcript += f"Context: {turn['scenario']}\n\n"
+            transcript += f"Student: {turn.get('student', '')}\n\n"
+            transcript += f"{name}: {turn.get('client', '')}\n\n"
+            transcript += "�" * 63 + "\n"
+        
+        if state_history:
+            transcript += f"""
+���������������������������������������������������������������
+EMOTIONAL STATE PROGRESSION
+���������������������������������������������������������������
+
+Initial State:
+  Anxiety: {state_history[0].get('anxiety', 0):.2f}
+  Trust: {state_history[0].get('trust', 0):.2f}
+  Openness: {state_history[0].get('openness', 0):.2f}
+
+Final State:
+  Anxiety: {state_history[-1].get('anxiety', 0):.2f}
+  Trust: {state_history[-1].get('trust', 0):.2f}
+  Openness: {state_history[-1].get('openness', 0):.2f}
+
+Change:
+  Anxiety: {state_history[-1].get('anxiety', 0) - state_history[0].get('anxiety', 0):+.2f}
+  Trust: {state_history[-1].get('trust', 0) - state_history[0].get('trust', 0):+.2f}
+  Openness: {state_history[-1].get('openness', 0) - state_history[0].get('openness', 0):+.2f}
+
+���������������������������������������������������������������
+"""
+        
+        # Save to temporary file
+        filename = f"{name}_{timestamp}.txt"
+        filepath = os.path.join("transcripts", filename)
+        os.makedirs("transcripts", exist_ok=True)
+        
+        with open(filepath, "w", encoding="utf-8") as f:
+            f.write(transcript)
+        
+        return filepath
+        
+    except Exception as e:
+        safe_log("Download error", str(e))
+        return None
+
+# Main simulation function
+def simulate(student_prompt, selected_scenario, selected_persona_file, conversation_history, state_history):
+    try:
+        persona_path = os.path.join(persona_dir, selected_persona_file)
+        persona = load_persona(persona_path)
+        
+        # Parse conversation history
+        if conversation_history is None:
+            conversation_history = []
+        if state_history is None:
+            state_history = []
+
+        # Load and apply contextual scenario
+        with open(contexts_path, "r") as f:
+            scenarios = json.load(f)
+        scenario = next((s for s in scenarios if s["scenario"] == selected_scenario), None)
+
+        if scenario:
+            persona = apply_context_shift(persona, scenario)
+            context_note = f"**Context:** {scenario.get('description', selected_scenario)}\n\n"
+        else:
+            context_note = ""
+
+        # Generate response
+        response, updated_state, teaching_note = generate_response(
+            student_prompt, 
+            persona, 
+            conversation_history
+        )
+        
+        # Update conversation history
+        conversation_history.append({
+            "student": student_prompt,
+            "client": response,
+            "scenario": selected_scenario
+        })
+        
+        # Track state history
+        state_history.append(updated_state.copy())
+        
+        # Format conversation display
+        conversation_display = ""
+        for i, turn in enumerate(conversation_history, 1):
+            conversation_display += f"**Turn {i}**\n"
+            if 'scenario' in turn:
+                conversation_display += f"*[Context: {turn['scenario']}]*\n"
+            conversation_display += f"**Student:** {turn['student']}\n\n"
+            conversation_display += f"**{persona['persona_name']}:** {turn['client']}\n\n"
+            conversation_display += "---\n\n"
+        
+        # Generate visualizations
+        state_yaml = yaml.dump(updated_state, sort_keys=False)
+        current_chart = plot_state(updated_state, persona['persona_name'])
+        history_chart = plot_interaction_history(state_history)
+        
+        # Format teaching feedback
+        teaching_feedback = f"**Teaching Note:**\n{teaching_note}\n\n"
+        teaching_feedback += f"**Current State:**\n"
+        teaching_feedback += f"- Anxiety: {updated_state.get('anxiety', 0):.2f}\n"
+        teaching_feedback += f"- Trust: {updated_state.get('trust', 0):.2f}\n"
+        teaching_feedback += f"- Openness: {updated_state.get('openness', 0):.2f}\n"
+        
+        if 'emotional_memory' in updated_state and updated_state['emotional_memory']:
+            teaching_feedback += f"\n**Emotional Memory:** {updated_state['emotional_memory'][-1]}\n"
+        
+        # Log interaction
+        transcript_path = log_interaction(
+            persona, 
+            student_prompt, 
+            selected_scenario, 
+            response, 
+            updated_state,
+            teaching_note
+        )
+        
+        return (
+            conversation_display,
+            teaching_feedback,
+            state_yaml,
+            current_chart,
+            history_chart,
+            conversation_history,
+            state_history
+        )
+
+    except Exception as e:
+        error_msg = traceback.format_exc()
+        safe_log("Simulation error", error_msg)
+        return (
+            "[ERROR] Simulation failed. Check logs.", 
+            "Error occurred",
+            "", 
+            None, 
+            None,
+            conversation_history,
+            state_history
+        )
+
+# Gradio UI
+with gr.Blocks(title="OT Mental Health Simulator", theme=gr.themes.Soft()) as ui:
+    gr.Markdown("""
+    # ?? OT Mental Health Training Simulator
+    ### Practice therapeutic communication with realistic client personas
+    
+    This simulator helps OT students develop skills in:
+    - Therapeutic rapport building
+    - Active listening and validation
+    - Recognizing emotional states and triggers
+    - Adapting communication based on client responses
+    - Understanding occupational impacts of mental health
+    """)
+    
+    # State management
+    conversation_state = gr.State([])
+    state_history = gr.State([])
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            persona_files = get_persona_choices()
+            default_persona = persona_files[0] if persona_files else None
+
+            persona_selector = gr.Dropdown(
+                label="Select Client",
+                choices=persona_files,
+                value=default_persona,
+                allow_custom_value=False,
+                info="Choose which client you'll be working with"
+            )
+            
+            scenario_selector = gr.Dropdown(
+                label="Contextual Scenario", 
+                choices=get_scenario_choices(), 
+                value=get_scenario_choices()[0] if get_scenario_choices() else None,
+                info="What's happening in the client's life right now?"
+            )
+            
+            gr.Markdown("---")
+            
+            with gr.Accordion("Client Information", open=False):
+                gr.Markdown("""
+                **Jack (22)** - Construction worker navigating chronic pain, family dynamics, 
+                burnout, and identity questions around gaming vs. career.
+                
+                **Maya (24)** - Graphic designer experiencing creative burnout, work-life imbalance, 
+                anxiety, and physical symptoms from overwork.
+                """)
+        
+        with gr.Column(scale=2):
+            conversation_display = gr.Markdown(
+                label="Conversation History",
+                value="*Conversation will appear here...*"
+            )
+    
+    with gr.Row():
+        student_prompt = gr.Textbox(
+            label="Your Response (as OT student/practitioner)",
+            lines=3,
+            placeholder="Type your therapeutic response here...\nExample: 'It sounds like work has been really demanding lately. How has that been affecting your daily routine?'"
+        )
+    
+    with gr.Row():
+        send_btn = gr.Button("Send Response", variant="primary", size="lg")
+        download_btn = gr.Button("?? Download Session", size="lg")
+        reset_btn = gr.Button("Reset Conversation", size="lg")
+    
+    with gr.Row():
+        with gr.Column():
+            teaching_output = gr.Markdown(label="Teaching Feedback")
+        
+        with gr.Column():
+            state_output = gr.Textbox(
+                label="Technical State (for debugging)", 
+                lines=8,
+                visible=False  # Hide by default, can be toggled
+            )
+    
+    with gr.Row():
+        with gr.Column():
+            current_state_chart = gr.Image(label="Current Emotional State")
+        
+        with gr.Column():
+            history_chart = gr.Image(label="Progress Over Time")
+    
+    # Hidden file output for downloads
+    download_file = gr.File(label="Your session transcript (right-click to save)", visible=True)
+    
+    with gr.Accordion("Instructor Guide", open=False):
+        gr.Markdown("""
+        ### How to Use This Simulator
+        
+        1. **Select a client** (Jack or Maya)
+        2. **Choose a scenario** to set the context
+        3. **Type your therapeutic response** as if you were the OT practitioner
+        4. **Observe** how the client responds based on:
+           - Their emotional state (anxiety, trust, openness)
+           - The scenario context
+           - Your communication approach
+        5. **Review teaching feedback** to understand what worked or didn't
+        6. **Track progress** through the radar chart and history graph
+        
+        ### Teaching Points
+        - Notice how validation vs. advice-giving affects trust
+        - Observe how pacing affects client openness
+        - See how boundary-setting affects the therapeutic relationship
+        - Track how emotional states shift with different approaches
+        
+        ### Sample Scenarios to Explore
+        - Building initial rapport
+        - Responding to resistance
+        - Addressing pain and physical symptoms
+        - Exploring occupational balance
+        - Managing therapeutic ruptures
+        - Crisis response
+        """)
+    
+    # Button actions
+    send_btn.click(
+        fn=simulate,
+        inputs=[
+            student_prompt, 
+            scenario_selector, 
+            persona_selector,
+            conversation_state,
+            state_history
+        ],
+        outputs=[
+            conversation_display,
+            teaching_output,
+            state_output,
+            current_state_chart,
+            history_chart,
+            conversation_state,
+            state_history
+        ]
+    )
+    
+    download_btn.click(
+        fn=download_session,
+        inputs=[
+            conversation_state,
+            state_history,
+            persona_selector
+        ],
+        outputs=download_file
+    )
+    
+    def reset_conversation():
+        return (
+            "*Conversation will appear here...*",
+            "",
+            "",
+            None,
+            None,
+            [],
+            []
+        )
+    
+    reset_btn.click(
+        fn=reset_conversation,
+        inputs=[],
+        outputs=[
+            conversation_display,
+            teaching_output,
+            state_output,
+            current_state_chart,
+            history_chart,
+            conversation_state,
+            state_history
+        ]
+    )
+
+if __name__ == "__main__":
+    # Create necessary directories
+    os.makedirs("personas", exist_ok=True)
+    os.makedirs("contexts", exist_ok=True)
+    os.makedirs("transcripts", exist_ok=True)
+    os.makedirs("engine", exist_ok=True)
+    
+    ui.launch(share=False, server_name="0.0.0.0", server_port=7860)

requirements.txt

@@ -0,0 +1,6 @@
+gradio>=4.0.0
+pyyaml>=6.0
+matplotlib>=3.5.0
+numpy>=1.21.0
+huggingface-hub>=0.20.0
+anthropic>=0.18.0