Create app.py

app.py

@@ -0,0 +1,831 @@
+#!/usr/bin/env python3
+"""
+CICE 2.0 Healthcare Assessment Tool - Gradio Version
+Converts the Google Colab notebook to a deployable Gradio application
+"""
+
+import gradio as gr
+import google.generativeai as genai
+import os
+import time
+from datetime import datetime
+import re
+from gtts import gTTS
+import tempfile
+import io
+import base64
+
+# Configuration
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+if not GOOGLE_API_KEY:
+    raise ValueError("GOOGLE_API_KEY environment variable must be set. Please add it to your HuggingFace Space secrets.")
+genai.configure(api_key=GOOGLE_API_KEY)
+
+class CICEAssessment:
+    def __init__(self):
+        self.model = genai.GenerativeModel("gemini-2.0-flash-exp")
+
+    def analyze_video(self, video_path):
+        """Analyze video using the 18-point CICE 2.0 assessment"""
+        
+        if not video_path:
+            return "❌ No video file provided. Please upload a video file."
+        
+        try:
+            print("📤 Uploading video to Gemini...")
+            video_file = genai.upload_file(path=video_path, display_name="healthcare_interaction")
+
+            # Wait for processing
+            print("⏳ Processing video (this may take 1-2 minutes)...")
+            max_wait = 300
+            wait_time = 0
+            while video_file.state.name == "PROCESSING" and wait_time < max_wait:
+                time.sleep(3)
+                wait_time += 3
+                video_file = genai.get_file(video_file.name)
+
+            if video_file.state.name == "FAILED":
+                return "❌ Video processing failed. Please try again with a different video file."
+
+            print("🤖 Analyzing with CICE 2.0 criteria...")
+
+            # THE 18-POINT CICE 2.0 ASSESSMENT PROMPT
+            prompt = """Analyze this healthcare team interaction video and provide a comprehensive assessment based on the CICE 2.0 instrument's 18 interprofessional competencies.
+
+            For EACH of the following 18 competencies, clearly state whether it was "OBSERVED" or "NOT OBSERVED" and provide specific examples with timestamps when possible:
+
+            1. IDENTIFIES FACTORS INFLUENCING HEALTH STATUS
+               - Did anyone verbalize factors affecting the patient's health (medical history, social determinants, lifestyle factors)?
+
+            2. IDENTIFIES TEAM GOALS FOR THE PATIENT
+               - Were specific team goals for the patient discussed or established?
+
+            3. PRIORITIZES GOALS FOCUSED ON IMPROVING HEALTH OUTCOMES
+               - Was there clear prioritization of goals to improve patient health outcomes?
+
+            4. VERBALIZES DISCIPLINE-SPECIFIC ROLE
+               - Did team members introduce themselves and clearly state their professional role (e.g., "I'm Dr. Smith, the attending physician")?
+
+            5. OFFERS TO SEEK GUIDANCE FROM COLLEAGUES
+               - Did anyone express uncertainty and offer to consult with colleagues of the same discipline when unsure?
+
+            6. COMMUNICATES ABOUT COST-EFFECTIVE AND TIMELY CARE
+               - Was there discussion about generic medications, diagnostic utility, or efficient care delivery?
+
+            7. DIRECTS QUESTIONS TO OTHER HEALTH PROFESSIONALS BASED ON EXPERTISE
+               - Were questions appropriately directed to specific team members based on their expertise?
+
+            8. AVOIDS DISCIPLINE-SPECIFIC TERMINOLOGY
+               - Did team members avoid or explain medical jargon, acronyms, and abbreviations when speaking?
+
+            9. EXPLAINS DISCIPLINE-SPECIFIC TERMINOLOGY WHEN NECESSARY
+               - When technical terms were used, were they explained professionally when clarification was needed?
+
+            10. COMMUNICATES ROLES AND RESPONSIBILITIES CLEARLY
+                - Were individual responsibilities and roles clearly articulated?
+
+            11. ENGAGES IN ACTIVE LISTENING
+                - Was there evidence of active listening through verbal acknowledgments, nonverbal cues, or engaging responses?
+
+            12. SOLICITS AND ACKNOWLEDGES PERSPECTIVES
+                - Did team members actively ask for and acknowledge input from other team members?
+
+            13. RECOGNIZES APPROPRIATE CONTRIBUTIONS
+                - Was there verbal or nonverbal recognition when team members made valuable contributions to patient care?
+
+            14. RESPECTFUL OF OTHER TEAM MEMBERS
+                - Was professionalism maintained? Were team members' expertise and lived experiences recognized?
+
+            15. COLLABORATIVELY WORKS THROUGH INTERPROFESSIONAL CONFLICTS
+                - If disagreements occurred, were they handled professionally and collaboratively?
+
+            16. REFLECTS ON STRENGTHS OF TEAM INTERACTIONS
+                - Did anyone comment on what went well in the team interaction?
+
+            17. REFLECTS ON CHALLENGES OF TEAM INTERACTIONS
+                - Were difficulties or areas for improvement explicitly discussed?
+
+            18. IDENTIFIES HOW TO IMPROVE TEAM EFFECTIVENESS
+                - Were specific suggestions made for improving future team collaboration?
+
+            STRUCTURE YOUR RESPONSE AS FOLLOWS:
+
+            ## OVERALL ASSESSMENT
+            Provide a brief overview of the team interaction quality and professionalism.
+
+            ## DETAILED COMPETENCY EVALUATION
+            For each of the 18 competencies, format as:
+
+            Competency [number]: [name]
+            Status: [OBSERVED/NOT OBSERVED]
+            Evidence: [Specific examples from the video, or explanation of why it wasn't observed]
+
+            ## STRENGTHS
+            List 3-5 key strengths observed in the team interaction
+
+            ## AREAS FOR IMPROVEMENT
+            List 3-5 specific areas where the team could improve
+
+            ## RECOMMENDATIONS
+            Provide 3-5 actionable recommendations for enhancing team collaboration and patient care
+
+            ## FINAL SCORE
+            Competencies Observed: X/18
+            Overall Performance Level: [Exemplary/Proficient/Developing/Needs Improvement]"""
+
+            response = self.model.generate_content([video_file, prompt])
+            return response.text
+
+        except Exception as e:
+            return f"❌ Error during assessment: {str(e)}"
+
+    def generate_audio_feedback(self, text):
+        """Convert assessment text to audio feedback"""
+        
+        try:
+            # Clean text for speech
+            clean_text = re.sub(r'[#*_\[\]()]', ' ', text)
+            clean_text = re.sub(r'\s+', ' ', clean_text)
+            clean_text = re.sub(r'[-•·]\s+', '', clean_text)
+            
+            # Limit text length for audio (gTTS has limits)
+            if len(clean_text) > 5000:
+                clean_text = clean_text[:5000] + "... Assessment continues in the text report."
+
+            # Generate audio with gTTS
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".mp3") as tmp_file:
+                tts = gTTS(text=clean_text, lang='en', slow=False)
+                tts.save(tmp_file.name)
+                return tmp_file.name
+                
+        except Exception as e:
+            print(f"⚠️ Audio generation failed: {str(e)}")
+            return None
+
+    def create_summary_report(self, assessment_text):
+        """Create a visual summary of competencies observed"""
+        
+        # Parse the assessment to count observed competencies
+        observed_count = assessment_text.lower().count("observed") - assessment_text.lower().count("not observed")
+        total_competencies = 18
+        percentage = (observed_count / total_competencies) * 100
+
+        # Determine performance level
+        if percentage >= 85:
+            level = "Exemplary"
+            color = "#059669"
+        elif percentage >= 70:
+            level = "Proficient"
+            color = "#0891b2"
+        elif percentage >= 50:
+            level = "Developing"
+            color = "#f59e0b"
+        else:
+            level = "Needs Improvement"
+            color = "#dc2626"
+
+        summary_html = f"""
+        <div style="max-width:800px; margin:20px auto; padding:30px; background:white; border-radius:15px; box-shadow:0 4px 6px rgba(0,0,0,0.1);">
+            <h2 style="text-align:center; color:#1f2937;">CICE 2.0 Assessment Summary</h2>
+
+            <div style="display:flex; justify-content:space-around; margin:30px 0;">
+                <div style="text-align:center;">
+                    <div style="font-size:48px; font-weight:bold; color:{color};">{observed_count}/{total_competencies}</div>
+                    <div style="color:#6b7280;">Competencies Observed</div>
+                </div>
+                <div style="text-align:center;">
+                    <div style="font-size:48px; font-weight:bold; color:{color};">{percentage:.0f}%</div>
+                    <div style="color:#6b7280;">Overall Score</div>
+                </div>
+            </div>
+
+            <div style="text-align:center; padding:20px; background:#f9fafb; border-radius:10px;">
+                <div style="font-size:24px; font-weight:bold; color:{color};">Performance Level: {level}</div>
+            </div>
+
+            <div style="margin-top:30px;">
+                <h3>📋 CICE 2.0 Competency Areas:</h3>
+                <ol style="line-height:1.8; color:#374151;">
+                    <li>Health Status Factors</li>
+                    <li>Team Goals Identification</li>
+                    <li>Goal Prioritization</li>
+                    <li>Role Verbalization</li>
+                    <li>Seeking Guidance</li>
+                    <li>Cost-Effective Communication</li>
+                    <li>Expertise-Based Questions</li>
+                    <li>Avoiding Jargon</li>
+                    <li>Explaining Terminology</li>
+                    <li>Clear Role Communication</li>
+                    <li>Active Listening</li>
+                    <li>Soliciting Perspectives</li>
+                    <li>Recognizing Contributions</li>
+                    <li>Team Respect</li>
+                    <li>Conflict Resolution</li>
+                    <li>Strength Reflection</li>
+                    <li>Challenge Reflection</li>
+                    <li>Improvement Identification</li>
+                </ol>
+            </div>
+        </div>
+        """
+        
+        return summary_html
+
+def process_video_assessment(video_file):
+    """Main function to process video and return assessment results"""
+    
+    if not video_file:
+        return "❌ Please record or upload a video file to analyze.", "", None
+    
+    # Initialize assessment tool
+    assessor = CICEAssessment()
+    
+    # Analyze the video
+    assessment_result = assessor.analyze_video(video_file)
+    
+    if assessment_result.startswith("❌"):
+        return assessment_result, "", None
+    
+    # Create summary report
+    summary_html = assessor.create_summary_report(assessment_result)
+    
+    # Generate audio feedback
+    audio_path = assessor.generate_audio_feedback(assessment_result)
+    
+    return assessment_result, summary_html, audio_path
+
+def save_recorded_video(video_data_base64):
+    """Save the recorded video from base64 data"""
+    try:
+        # Decode base64 video data
+        video_data = base64.b64decode(video_data_base64)
+        
+        # Create temporary file
+        with tempfile.NamedTemporaryFile(delete=False, suffix=".webm") as tmp_file:
+            tmp_file.write(video_data)
+            return tmp_file.name
+            
+    except Exception as e:
+        print(f"Error saving recorded video: {e}")
+        return None
+
+def create_video_recorder_html():
+    """Create the HTML/JavaScript for video recording interface"""
+    
+    recorder_html = """
+    <div id="video-recorder-container" style="text-align: center; padding: 20px; background-color: #f0f0f0; border-radius: 10px;">
+        <h3>📹 Video Recorder - Healthcare Team Interaction</h3>
+        <video id="video" width="640" height="480" autoplay style="border: 2px solid #333; border-radius: 5px;"></video><br>
+        <div style="margin: 15px 0;">
+            <button id="start" class="btn" style="background-color: #4CAF50; color: white; padding: 10px 20px; margin: 5px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px;">🔴 Start Recording</button>
+            <button id="stop" class="btn" disabled style="background-color: #f44336; color: white; padding: 10px 20px; margin: 5px; border: none; border-radius: 4px; cursor: pointer; opacity: 0.5; font-size: 16px;">⏹️ Stop Recording</button>
+            <button id="reset" class="btn" style="background-color: #2196F3; color: white; padding: 10px 20px; margin: 5px; border: none; border-radius: 4px; cursor: pointer; font-size: 16px;">🔄 Reset</button>
+        </div>
+        <div id="timer" style="margin-top: 10px; font-size: 18px; font-weight: bold; color: #333;">Ready to record</div>
+        <div id="status" style="margin-top: 10px; color: #666; font-size: 14px;"></div>
+        <div id="fileStatus" style="margin-top: 10px; color: #0066cc; font-weight: bold;"></div>
+        
+        <!-- Hidden elements for data transfer -->
+        <input type="hidden" id="recorded-video-data" />
+        <input type="hidden" id="recording-complete" value="false" />
+    </div>
+
+    <script>
+    (function() {
+        var video = document.querySelector('#video');
+        var startBtn = document.querySelector('#start');
+        var stopBtn = document.querySelector('#stop');
+        var resetBtn = document.querySelector('#reset');
+        var timerDiv = document.querySelector('#timer');
+        var statusDiv = document.querySelector('#status');
+        var fileStatusDiv = document.querySelector('#fileStatus');
+        var recordedDataInput = document.querySelector('#recorded-video-data');
+        var recordingCompleteInput = document.querySelector('#recording-complete');
+        
+        var mediaRecorder;
+        var recordedBlobs = [];
+        var stream;
+        var startTime;
+        var timerInterval;
+        var recordingCount = 0;
+
+        // Clear any previous status
+        fileStatusDiv.textContent = '';
+        statusDiv.textContent = 'Initializing camera and microphone...';
+
+        // Request camera and microphone access
+        navigator.mediaDevices.getUserMedia({
+            video: {
+                width: { ideal: 640, max: 640 },
+                height: { ideal: 480, max: 480 },
+                frameRate: { ideal: 24, max: 30 }
+            },
+            audio: {
+                echoCancellation: true,
+                noiseSuppression: true,
+                sampleRate: 44100
+            }
+        })
+        .then(function(s) {
+            stream = s;
+            video.srcObject = stream;
+            statusDiv.textContent = '✅ Camera and microphone ready! Click Start to begin recording.';
+            fileStatusDiv.textContent = 'No recording yet. Click Start to begin.';
+        })
+        .catch(function(error) {
+            console.error('Error accessing media devices:', error);
+            statusDiv.textContent = '❌ Error: ' + error.message + '. Please allow camera/microphone access and refresh.';
+            statusDiv.style.color = 'red';
+        });
+
+        function updateTimer() {
+            var elapsed = Math.floor((Date.now() - startTime) / 1000);
+            var minutes = Math.floor(elapsed / 60);
+            var seconds = elapsed % 60;
+            timerDiv.textContent = '🔴 Recording: ' + minutes.toString().padStart(2, '0') + ':' + seconds.toString().padStart(2, '0');
+
+            var maxDuration = 900; // 15 minutes
+            var remaining = maxDuration - elapsed;
+            if (remaining > 0) {
+                var remMin = Math.floor(remaining / 60);
+                var remSec = remaining % 60;
+                statusDiv.textContent = 'Time remaining: ' + remMin + 'm ' + remSec + 's';
+            }
+
+            // Auto-stop at duration limit
+            if (elapsed >= maxDuration) {
+                console.log('Max duration reached, auto-stopping...');
+                stopBtn.click();
+            }
+        }
+
+        startBtn.addEventListener('click', function() {
+            if (!stream) {
+                alert('Please allow camera and microphone access first!');
+                return;
+            }
+
+            // Clear previous recording data
+            recordedBlobs = [];
+            recordingCount++;
+            recordingCompleteInput.value = 'false';
+
+            fileStatusDiv.textContent = '📹 Recording in progress...';
+            fileStatusDiv.style.color = '#ff6600';
+
+            // Configure recording options
+            var options = {
+                mimeType: 'video/webm;codecs=vp8,opus',
+                videoBitsPerSecond: 800000,
+                audioBitsPerSecond: 128000
+            };
+
+            // Fallback if codec not supported
+            if (!MediaRecorder.isTypeSupported(options.mimeType)) {
+                options = {
+                    mimeType: 'video/webm',
+                    bitsPerSecond: 1000000
+                };
+            }
+
+            try {
+                mediaRecorder = new MediaRecorder(stream, options);
+            } catch (e) {
+                console.error('Error creating MediaRecorder:', e);
+                alert('Error creating MediaRecorder: ' + e.message);
+                return;
+            }
+
+            startBtn.disabled = true;
+            startBtn.style.opacity = '0.5';
+            stopBtn.disabled = false;
+            stopBtn.style.opacity = '1';
+
+            startTime = Date.now();
+            timerInterval = setInterval(updateTimer, 1000);
+            updateTimer();
+
+            mediaRecorder.ondataavailable = function(event) {
+                if (event.data && event.data.size > 0) {
+                    recordedBlobs.push(event.data);
+                    console.log('Data chunk received, size:', event.data.size);
+                }
+            };
+
+            mediaRecorder.onstop = function() {
+                clearInterval(timerInterval);
+                timerDiv.textContent = '⏹️ Recording stopped - Processing...';
+                statusDiv.textContent = 'Processing and preparing video for analysis...';
+                fileStatusDiv.textContent = '💾 Creating video file...';
+                fileStatusDiv.style.color = '#0066cc';
+
+                // Process the recorded video
+                setTimeout(function() {
+                    try {
+                        // Combine all recorded chunks into a single blob
+                        var blob = new Blob(recordedBlobs, {type: 'video/webm'});
+                        console.log('Total video size:', blob.size, 'bytes');
+
+                        // Convert to base64
+                        var reader = new FileReader();
+                        reader.readAsDataURL(blob);
+                        reader.onloadend = function() {
+                            var base64data = reader.result.split(',')[1];
+                            
+                            // Store the base64 data in hidden input
+                            recordedDataInput.value = base64data;
+                            recordingCompleteInput.value = 'true';
+
+                            timerDiv.textContent = '✅ Recording complete!';
+                            statusDiv.textContent = 'Video ready for analysis. Click "Analyze Recording" below.';
+                            statusDiv.style.color = 'green';
+                            fileStatusDiv.textContent = '✅ Video recorded successfully (' + 
+                                (blob.size / 1024 / 1024).toFixed(2) + ' MB)';
+                            fileStatusDiv.style.color = 'green';
+
+                            // Trigger a change event to notify Gradio
+                            recordingCompleteInput.dispatchEvent(new Event('change'));
+
+                            // Clear recorded data to free memory
+                            recordedBlobs = [];
+                        };
+                    } catch (e) {
+                        console.error('Error processing video:', e);
+                        statusDiv.textContent = '❌ Error processing video: ' + e.message;
+                        statusDiv.style.color = 'red';
+                        fileStatusDiv.textContent = '❌ Video processing failed!';
+                        fileStatusDiv.style.color = 'red';
+                    }
+                }, 100);
+            };
+
+            // Start recording with periodic data collection
+            mediaRecorder.start(5000);  // Collect data every 5 seconds
+            console.log('Recording started - session #' + recordingCount);
+            statusDiv.style.color = '#666';
+        });
+
+        stopBtn.addEventListener('click', function() {
+            if (mediaRecorder && mediaRecorder.state === 'recording') {
+                console.log('Stopping recording...');
+                mediaRecorder.stop();
+                startBtn.disabled = false;
+                startBtn.style.opacity = '1';
+                stopBtn.disabled = true;
+                stopBtn.style.opacity = '0.5';
+            }
+        });
+
+        resetBtn.addEventListener('click', function() {
+            // Reset the interface
+            if (mediaRecorder && mediaRecorder.state === 'recording') {
+                mediaRecorder.stop();
+            }
+            recordedBlobs = [];
+            recordedDataInput.value = '';
+            recordingCompleteInput.value = 'false';
+            
+            startBtn.disabled = false;
+            startBtn.style.opacity = '1';
+            stopBtn.disabled = true;
+            stopBtn.style.opacity = '0.5';
+            timerDiv.textContent = 'Ready to record';
+            statusDiv.textContent = '✅ Camera and microphone ready! Click Start to begin recording.';
+            statusDiv.style.color = '#666';
+            fileStatusDiv.textContent = 'Interface reset. Ready for new recording.';
+            fileStatusDiv.style.color = '#0066cc';
+        });
+    })();
+    </script>
+    """
+    
+    return recorder_html
+
+def get_recorded_video_data():
+    """Get the recorded video data from the hidden input"""
+    # This will be called by Gradio when the recording is complete
+    return None
+
+def process_recorded_video(recording_complete, video_data_base64):
+    """Process the recorded video when recording is complete"""
+    
+    if recording_complete != 'true' or not video_data_base64:
+        return "❌ No recording available. Please record a video first.", "", None
+    
+    try:
+        # Save the recorded video
+        video_path = save_recorded_video(video_data_base64)
+        
+        if not video_path:
+            return "❌ Failed to save recorded video.", "", None
+        
+        # Process the video
+        return process_video_assessment(video_path)
+        
+    except Exception as e:
+        return f"❌ Error processing recorded video: {str(e)}", "", None
+
+def ask_question_about_assessment(question, video_file_or_data, assessment_result, is_recorded_video=False):
+    """Allow users to ask specific questions about the assessment"""
+    
+    if not assessment_result:
+        return "❌ Please record/upload and analyze a video first before asking questions."
+    
+    if not question.strip():
+        return "❌ Please enter a question about the assessment."
+    
+    try:
+        # Handle recorded video vs uploaded video
+        if is_recorded_video and video_file_or_data:
+            # For recorded video, save the base64 data first
+            video_path = save_recorded_video(video_file_or_data)
+            if not video_path:
+                return "❌ Could not process recorded video for Q&A."
+            uploaded_video = genai.upload_file(path=video_path, display_name="healthcare_interaction_qa")
+        elif video_file_or_data:
+            # For uploaded video file
+            uploaded_video = genai.upload_file(path=video_file_or_data, display_name="healthcare_interaction_qa")
+        else:
+            return "❌ No video available for Q&A."
+        
+        # Wait for processing
+        max_wait = 60
+        wait_time = 0
+        while uploaded_video.state.name == "PROCESSING" and wait_time < max_wait:
+            time.sleep(2)
+            wait_time += 2
+            uploaded_video = genai.get_file(uploaded_video.name)
+
+        model = genai.GenerativeModel("gemini-2.0-flash-exp")
+        
+        prompt = f"""Based on the CICE 2.0 assessment of this healthcare team video,
+        please answer this specific question: {question}
+
+        Refer to the relevant competencies from the 18-point CICE framework in your answer.
+        
+        Previous assessment results:
+        {assessment_result[:2000]}..."""  # Truncate to avoid token limits
+
+        response = model.generate_content([uploaded_video, prompt])
+        return response.text
+        
+    except Exception as e:
+        return f"❌ Error answering question: {str(e)}"
+
+# Global variables to store assessment state
+current_video = None
+current_assessment = None
+current_video_data = None
+is_current_recorded = False
+
+def store_assessment_state(video_file, assessment_result, summary_html, audio_path, video_data=None, is_recorded=False):
+    """Store the current assessment state for Q&A"""
+    global current_video, current_assessment, current_video_data, is_current_recorded
+    current_video = video_file
+    current_assessment = assessment_result
+    current_video_data = video_data
+    is_current_recorded = is_recorded
+    return assessment_result, summary_html, audio_path
+
+def qa_wrapper(question):
+    """Wrapper for Q&A functionality"""
+    global current_video, current_assessment, current_video_data, is_current_recorded
+    
+    if is_current_recorded:
+        return ask_question_about_assessment(question, current_video_data, current_assessment, True)
+    else:
+        return ask_question_about_assessment(question, current_video, current_assessment, False)
+
+# Create Gradio Interface
+def create_gradio_app():
+    """Create the main Gradio application"""
+    
+    with gr.Blocks(title="CICE 2.0 Healthcare Assessment Tool", theme=gr.themes.Soft()) as app:
+        
+        gr.Markdown("""
+        # 🏥 CICE 2.0 Healthcare Assessment Tool
+        
+        Record live healthcare team interactions or upload existing videos to receive comprehensive assessment based on the 18-point CICE 2.0 interprofessional competency framework.
+        
+        **Features:**
+        - 🎥 **Live Video Recording** with audio (just like in Colab!)
+        - 📁 Video file upload support
+        - ✅ 18-point competency evaluation
+        - 📊 Visual summary report
+        - 🔊 Audio feedback
+        - 💬 Interactive Q&A about results
+        - 📥 Downloadable assessment report
+        """)
+        
+        with gr.Tab("🎥 Record Video & Assess"):
+            gr.Markdown("### Record Live Healthcare Team Interaction")
+            
+            # Video recorder interface
+            recorder_interface = gr.HTML(
+                value=create_video_recorder_html(),
+                label="Video Recorder"
+            )
+            
+            # Hidden inputs to capture recording data
+            recording_complete = gr.Textbox(
+                value="false",
+                visible=False,
+                elem_id="recording-complete"
+            )
+            
+            recorded_video_data = gr.Textbox(
+                value="",
+                visible=False,
+                elem_id="recorded-video-data"
+            )
+            
+            with gr.Row():
+                analyze_recording_btn = gr.Button(
+                    "� Analyze Recording",
+                    variant="primary",
+                    size="lg"
+                )
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    recording_summary_output = gr.HTML(
+                        label="Assessment Summary",
+                        value="<p>Record a video and click 'Analyze Recording' to see the summary.</p>"
+                    )
+                
+                with gr.Column(scale=1):
+                    recording_audio_output = gr.Audio(
+                        label="🔊 Audio Feedback",
+                        visible=True
+                    )
+            
+            recording_assessment_output = gr.Textbox(
+                label="Detailed Assessment Report",
+                lines=15,
+                max_lines=25,
+                placeholder="Record a video and analyze it to see detailed CICE 2.0 assessment..."
+            )
+        
+        with gr.Tab("📁 Upload Video & Assess"):
+            gr.Markdown("### Upload Existing Healthcare Team Video")
+            
+            with gr.Row():
+                with gr.Column(scale=1):
+                    video_input = gr.Video(
+                        label="Upload Healthcare Team Video",
+                        height=400
+                    )
+                    
+                    assess_btn = gr.Button(
+                        "🔍 Analyze Video",
+                        variant="primary",
+                        size="lg"
+                    )
+                
+                with gr.Column(scale=2):
+                    summary_output = gr.HTML(
+                        label="Assessment Summary",
+                        value="<p>Upload a video and click 'Analyze Video' to see the summary.</p>"
+                    )
+            
+            with gr.Row():
+                assessment_output = gr.Textbox(
+                    label="Detailed Assessment Report",
+                    lines=20,
+                    max_lines=30,
+                    placeholder="Detailed CICE 2.0 assessment will appear here..."
+                )
+            
+            with gr.Row():
+                audio_output = gr.Audio(
+                    label="🔊 Audio Feedback",
+                    visible=True
+                )
+        
+        with gr.Tab("💬 Q&A About Assessment"):
+            gr.Markdown("Ask specific questions about the assessment results from either recorded or uploaded videos.")
+            
+            with gr.Row():
+                question_input = gr.Textbox(
+                    label="Your Question",
+                    placeholder="e.g., 'Was active listening demonstrated?' or 'How did the team handle conflicts?'",
+                    lines=2
+                )
+                ask_btn = gr.Button("Ask Question", variant="secondary")
+            
+            qa_output = gr.Textbox(
+                label="Answer",
+                lines=10,
+                placeholder="Answers to your questions will appear here..."
+            )
+            
+            gr.Markdown("""
+            **Example Questions:**
+            - Was active listening demonstrated?
+            - How did the team handle conflicts?
+            - What improvements are recommended?
+            - Which competencies were most strongly observed?
+            - What specific evidence was found for role verbalization?
+            """)
+        
+        with gr.Tab("📋 About CICE 2.0"):
+            gr.Markdown("""
+            ## About the CICE 2.0 Assessment Framework
+            
+            The Collaborative Interprofessional Competencies Evaluation (CICE) 2.0 is a validated instrument for assessing interprofessional collaboration competencies in healthcare teams.
+            
+            ### The 18 Core Competencies:
+            
+            **Values/Ethics:**
+            1. Health Status Factors
+            2. Team Goals Identification  
+            3. Goal Prioritization
+            4. Role Verbalization
+            5. Seeking Guidance
+            6. Cost-Effective Communication
+            
+            **Roles/Responsibilities:**
+            7. Expertise-Based Questions
+            8. Avoiding Jargon
+            9. Explaining Terminology
+            10. Clear Role Communication
+            
+            **Interprofessional Communication:**
+            11. Active Listening
+            12. Soliciting Perspectives
+            13. Recognizing Contributions
+            14. Team Respect
+            15. Conflict Resolution
+            
+            **Teams and Teamwork:**
+            16. Strength Reflection
+            17. Challenge Reflection
+            18. Improvement Identification
+            
+            ### Performance Levels:
+            - **Exemplary** (85%+): Exceptional interprofessional collaboration
+            - **Proficient** (70-84%): Good collaboration with minor areas for improvement
+            - **Developing** (50-69%): Adequate collaboration with several improvement opportunities
+            - **Needs Improvement** (<50%): Significant development required
+            
+            ### Recording Tips:
+            - Ensure good lighting and clear audio
+            - Position camera to capture all team members
+            - Allow natural team interactions
+            - Include patient case discussions
+            - Record for at least 5-10 minutes for comprehensive assessment
+            """)
+        
+        # Event handlers for recorded videos
+        analyze_recording_btn.click(
+            fn=lambda complete, data: store_assessment_state(
+                None, 
+                *process_recorded_video(complete, data), 
+                video_data=data, 
+                is_recorded=True
+            ),
+            inputs=[recording_complete, recorded_video_data],
+            outputs=[recording_assessment_output, recording_summary_output, recording_audio_output]
+        )
+        
+        # Event handlers for uploaded videos
+        assess_btn.click(
+            fn=lambda video: store_assessment_state(video, *process_video_assessment(video)),
+            inputs=[video_input],
+            outputs=[assessment_output, summary_output, audio_output]
+        )
+        
+        # Q&A handlers
+        ask_btn.click(
+            fn=qa_wrapper,
+            inputs=[question_input],
+            outputs=[qa_output]
+        )
+        
+        # Enter key support for questions
+        question_input.submit(
+            fn=qa_wrapper,
+            inputs=[question_input],
+            outputs=[qa_output]
+        )
+        
+        # Auto-detect when recording is complete (JavaScript to Gradio communication)
+        recording_complete.change(
+            fn=lambda: None,  # Just trigger an update
+            inputs=[],
+            outputs=[]
+        )
+    
+    return app
+
+if __name__ == "__main__":
+    # Create and launch the app
+    app = create_gradio_app()
+    
+    # Launch with sharing enabled for deployment
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=True,
+        show_error=True
+    )