Update session_analysis.py

session_analysis.py

@@ -61,25 +61,36 @@ def show_upload_section():
 def process_video_file(video_file):
     """Process uploaded video file"""
     try:
-        # Save video temporarily
+        # Create a unique temporary file name
         temp_path = f"temp_video_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp4"
+        
+        # Save video temporarily
         with open(temp_path, "wb") as f:
             f.write(video_file.getbuffer())
         
+        # Display video
         st.video(temp_path)
-        st.info("Video uploaded successfully. Please provide transcript.")
         
-        # Add manual transcript input
-        transcript = st.text_area("Enter the session transcript:", height=300)
+        # Add transcript input
+        transcript = st.text_area(
+            "Enter the session transcript:",
+            height=300,
+            help="Paste or type the transcript of the session here."
+        )
         
         # Add analyze button
         if st.button("Analyze Transcript"):
-            if transcript:
+            if transcript.strip():
                 with st.spinner('Analyzing transcript...'):
-                    st.session_state.current_transcript = transcript
                     analyze_session_content(transcript)
             else:
                 st.warning("Please enter a transcript before analyzing.")
+                
+        # Clean up temporary file
+        try:
+            os.remove(temp_path)
+        except:
+            pass
             
     except Exception as e:
         st.error(f"Error processing video: {str(e)}")
@@ -785,42 +796,74 @@ def format_session_data(session_data):
     return formatted_text
 
 def analyze_session_content(transcript):
+    """Analyze the session transcript using Gemini"""
     try:
-        # Initialize Gemini
+        if not transcript:
+            st.warning("Please provide a transcript for analysis.")
+            return
+
+        # Configure the model
         model = genai.GenerativeModel('gemini-pro')
         
-        # Prepare the analysis prompt
-        analysis_prompt = f"""
-        {MI_SYSTEM_PROMPT}
-        
-        Please analyze the following therapy session transcript:
-        
+        # Prepare prompt with structured output request
+        prompt = """
+        Analyze this MI (Motivational Interviewing) session transcript and provide analysis in the following structured format:
+
+        MI Adherence Score: [0-100]
+
+        Key Themes:
+        - [Theme 1]
+        - [Theme 2]
+        - [Theme 3]
+
+        Technique Usage:
+        - Open Questions: [count]
+        - Reflections: [count]
+        - Affirmations: [count]
+        - Summaries: [count]
+
+        Strengths:
+        - [Strength 1]
+        - [Strength 2]
+        - [Strength 3]
+
+        Areas for Improvement:
+        - [Area 1]
+        - [Area 2]
+        - [Area 3]
+
+        Change Talk Instances:
+        - [Example 1]
+        - [Example 2]
+
+        Sustain Talk Instances:
+        - [Example 1]
+        - [Example 2]
+
+        Session Summary:
+        [Brief summary of the session flow and key moments]
+
+        Transcript to analyze:
         {transcript}
-        
-        {SESSION_EVALUATION_PROMPT}
         """
         
-        # Generate analysis
-        response = model.generate_content(analysis_prompt)
-        
-        # Parse the response
-        analysis_results = parse_analysis_response(response.text)
+        # Generate response
+        response = model.generate_content(prompt)
         
         # Store results in session state
-        st.session_state.analysis_results = analysis_results
+        st.session_state.analysis_results = response.text
+        
+        # Trigger results display
+        show_analysis_results()
         
     except Exception as e:
-        st.error(f"Error analyzing session content: {str(e)}")
+        st.error(f"Error analyzing session: {str(e)}")
+
 
 def show_analysis_results():
     """Display the analysis results in the dashboard"""
-    if not st.session_state.analysis_results:
-        return
-    
-    # Parse the results
-    analysis = parse_analysis_results(st.session_state.analysis_results)
-    if not analysis:
-        st.error("Unable to parse analysis results")
+    if 'analysis_results' not in st.session_state or not st.session_state.analysis_results:
+        st.info("No analysis results available. Please analyze a transcript first.")
         return
 
     # Create tabs for different aspects of analysis
@@ -835,110 +878,132 @@ def show_analysis_results():
     # MI Adherence Tab
     with tabs[0]:
         st.subheader("MI Adherence Score")
-        score = analysis.get('mi_adherence_score', 0)
-        create_gauge_chart(score)
         
-        col1, col2 = st.columns(2)
-        with col1:
+        # Extract score from analysis results
+        score_match = re.search(r'MI Adherence Score:\s*(\d+)', st.session_state.analysis_results)
+        if score_match:
+            score = int(score_match.group(1))
+            
+            # Create score gauge
+            fig = go.Figure(go.Indicator(
+                mode="gauge+number",
+                value=score,
+                domain={'x': [0, 1], 'y': [0, 1]},
+                gauge={'axis': {'range': [0, 100]},
+                       'bar': {'color': "rgb(26, 118, 255)"},
+                       'steps': [
+                           {'range': [0, 33], 'color': "lightgray"},
+                           {'range': [33, 66], 'color': "gray"},
+                           {'range': [66, 100], 'color': "darkgray"}
+                       ]}))
+            st.plotly_chart(fig)
+
+        # Extract and display strengths
+        strengths = re.findall(r'Strengths:\n((?:- .*\n)*)', st.session_state.analysis_results)
+        if strengths:
             st.subheader("Strengths")
-            for strength in analysis.get('strengths', []):
-                st.markdown(f"✅ {strength}")
-        
-        with col2:
+            strength_list = strengths[0].strip().split('\n')
+            for strength in strength_list:
+                if strength.startswith('- '):
+                    st.markdown(f"✅ {strength[2:]}")
+
+        # Extract and display areas for improvement
+        improvements = re.findall(r'Areas for Improvement:\n((?:- .*\n)*)', st.session_state.analysis_results)
+        if improvements:
             st.subheader("Areas for Improvement")
-            for area in analysis.get('areas_for_improvement', []):
-                st.markdown(f"🔄 {area}")
+            improvement_list = improvements[0].strip().split('\n')
+            for improvement in improvement_list:
+                if improvement.startswith('- '):
+                    st.markdown(f"🔄 {improvement[2:]}")
 
     # Technical Skills Tab
     with tabs[1]:
         st.subheader("MI Technique Usage")
-        technique_data = analysis.get('technique_usage', {})
         
-        # Create bar chart for technique usage
-        if technique_data:
-            fig = go.Figure(data=[
-                go.Bar(
-                    x=list(technique_data.keys()),
-                    y=list(technique_data.values()),
-                    marker_color='rgb(26, 118, 255)'
-                )
-            ])
-            
-            fig.update_layout(
-                title="Technique Usage Frequency",
-                xaxis_title="Technique",
-                yaxis_title="Count",
-                template="plotly_white"
+        # Extract technique counts
+        techniques = {
+            'Open Questions': 0,
+            'Reflections': 0,
+            'Affirmations': 0,
+            'Summaries': 0
+        }
+        
+        for technique in techniques.keys():
+            count_match = re.search(f'{technique}:\s*(\d+)', st.session_state.analysis_results)
+            if count_match:
+                techniques[technique] = int(count_match.group(1))
+        
+        # Create bar chart
+        fig = go.Figure(data=[
+            go.Bar(
+                x=list(techniques.keys()),
+                y=list(techniques.values()),
+                marker_color='rgb(26, 118, 255)'
             )
-            st.plotly_chart(fig)
+        ])
         
-        # Technique breakdown
-        for technique, count in technique_data.items():
-            with st.expander(f"{technique} ({count} instances)"):
-                st.write(get_technique_description(technique))
+        fig.update_layout(
+            title="Technique Usage Frequency",
+            xaxis_title="Technique",
+            yaxis_title="Count",
+            template="plotly_white"
+        )
+        st.plotly_chart(fig)
 
     # Client Language Tab
     with tabs[2]:
         st.subheader("Client Language Analysis")
         
-        # Create columns for different types of client language
-        col1, col2 = st.columns(2)
-        
-        with col1:
+        # Extract change talk
+        change_talk = re.findall(r'Change Talk Instances:\n((?:- .*\n)*)', st.session_state.analysis_results)
+        if change_talk:
             st.markdown("### Change Talk 🌱")
-            change_talk = analysis.get('change_talk', [])
-            if change_talk:
-                for talk in change_talk:
-                    st.markdown(f"- {talk}")
-            else:
-                st.info("No specific change talk identified")
-
-        with col2:
+            changes = change_talk[0].strip().split('\n')
+            for change in changes:
+                if change.startswith('- '):
+                    st.markdown(f"- {change[2:]}")
+        
+        # Extract sustain talk
+        sustain_talk = re.findall(r'Sustain Talk Instances:\n((?:- .*\n)*)', st.session_state.analysis_results)
+        if sustain_talk:
             st.markdown("### Sustain Talk 🔄")
-            sustain_talk = analysis.get('sustain_talk', [])
-            if sustain_talk:
-                for talk in sustain_talk:
-                    st.markdown(f"- {talk}")
-            else:
-                st.info("No specific sustain talk identified")
+            sustains = sustain_talk[0].strip().split('\n')
+            for sustain in sustains:
+                if sustain.startswith('- '):
+                    st.markdown(f"- {sustain[2:]}")
 
     # Session Flow Tab
     with tabs[3]:
         st.subheader("Session Flow Analysis")
         
-        # Display key themes
-        st.markdown("### Key Themes 🎯")
-        themes = analysis.get('key_themes', [])
-        for theme in themes:
-            st.markdown(f"- {theme}")
-        
-        # Session structure
-        st.markdown("### Session Structure")
-        session_summary = analysis.get('session_summary', '')
-        if session_summary:
-            st.write(session_summary)
+        # Extract key themes
+        themes = re.findall(r'Key Themes:\n((?:- .*\n)*)', st.session_state.analysis_results)
+        if themes:
+            st.markdown("### Key Themes 🎯")
+            theme_list = themes[0].strip().split('\n')
+            for theme in theme_list:
+                if theme.startswith('- '):
+                    st.markdown(f"- {theme[2:]}")
         
-        # Add timeline visualization if available
-        if 'timeline' in analysis:
-            create_session_timeline(analysis['timeline'])
+        # Extract session summary
+        summary_match = re.search(r'Session Summary:\n(.*?)(?=\n\n|\Z)', st.session_state.analysis_results, re.DOTALL)
+        if summary_match:
+            st.markdown("### Session Summary")
+            st.write(summary_match.group(1).strip())
 
     # Recommendations Tab
     with tabs[4]:
         st.subheader("Recommendations for Improvement")
         
-        # Priority recommendations
-        st.markdown("### Priority Areas 🎯")
-        for area in analysis.get('areas_for_improvement', [])[:3]:  # Top 3 priorities
-            st.markdown(f"**1️⃣ {area}**")
-            st.markdown(get_improvement_suggestion(area))
-        
-        # Specific action items
-        st.markdown("### Action Items ✅")
-        create_action_items(analysis)
-        
-        # Resources
-        st.markdown("### Helpful Resources 📚")
-        show_relevant_resources(analysis)
+        # Display improvement areas as recommendations
+        if improvements:
+            st.markdown("### Priority Areas 🎯")
+            improvement_list = improvements[0].strip().split('\n')
+            for i, improvement in enumerate(improvement_list[:3], 1):
+                if improvement.startswith('- '):
+                    st.markdown(f"**{i}. {improvement[2:]}**")
+                    st.markdown(get_improvement_suggestion(improvement[2:]))
+
 
 def get_technique_description(technique):
     """Return description for MI techniques"""
@@ -1058,6 +1123,22 @@ def parse_analysis_response(response_text):
         st.error(f"Error parsing analysis response: {str(e)}")
         return None
 
+def get_improvement_suggestion(area):
+    """Return specific suggestions for improvement areas"""
+    suggestions = {
+        "open questions": "Practice replacing closed questions with open-ended ones. For example:\n- Instead of: 'Did you exercise?'\n- Try: 'What kinds of physical activity have you been doing?'",
+        "reflections": "Work on using more complex reflections by adding meaning or emotion to what the client has said. Try to make at least two complex reflections for every simple reflection.",
+        "empathy": "Focus on seeing the situation from the client's perspective. Take time to verbalize your understanding of their emotions and experiences.",
+        "summaries": "Use more collecting summaries to gather key points discussed and transition summaries to move between topics.",
+        "affirmations": "Look for opportunities to genuinely affirm client strengths and efforts, not just outcomes."
+    }
+    
+    # Look for matching suggestions using partial string matching
+    for key, value in suggestions.items():
+        if key in area.lower():
+            return value
+    return "Focus on incorporating this element more intentionally in your sessions. Consider recording your sessions and reviewing them with a supervisor or peer."
+
 def create_gauge_chart(score):
     """Create a gauge chart for MI Adherence Score"""
     fig = go.Figure(go.Indicator(