Update session_analysis.py

session_analysis.py

@@ -67,13 +67,19 @@ def process_video_file(video_file):
             f.write(video_file.getbuffer())
         
         st.video(temp_path)
-        st.info("Video uploaded successfully. Please note: automatic transcription is not yet implemented. Please provide transcript manually.")
+        st.info("Video uploaded successfully. Please provide transcript.")
         
         # Add manual transcript input
-        transcript = st.text_area("Please enter the session transcript:", height=300)
-        if transcript:
-            st.session_state.current_transcript = transcript
-            analyze_session_content(transcript)
+        transcript = st.text_area("Enter the session transcript:", height=300)
+        
+        # Add analyze button
+        if st.button("Analyze Transcript"):
+            if transcript:
+                with st.spinner('Analyzing transcript...'):
+                    st.session_state.current_transcript = transcript
+                    analyze_session_content(transcript)
+            else:
+                st.warning("Please enter a transcript before analyzing.")
             
     except Exception as e:
         st.error(f"Error processing video: {str(e)}")
@@ -87,13 +93,19 @@ def process_audio_file(audio_file):
             f.write(audio_file.getbuffer())
         
         st.audio(temp_path)
-        st.info("Audio uploaded successfully. Please note: automatic transcription is not yet implemented. Please provide transcript manually.")
+        st.info("Audio uploaded successfully. Please provide transcript.")
         
         # Add manual transcript input
-        transcript = st.text_area("Please enter the session transcript:", height=300)
-        if transcript:
-            st.session_state.current_transcript = transcript
-            analyze_session_content(transcript)
+        transcript = st.text_area("Enter the session transcript:", height=300)
+        
+        # Add analyze button
+        if st.button("Analyze Transcript"):
+            if transcript:
+                with st.spinner('Analyzing transcript...'):
+                    st.session_state.current_transcript = transcript
+                    analyze_session_content(transcript)
+            else:
+                st.warning("Please enter a transcript before analyzing.")
             
     except Exception as e:
         st.error(f"Error processing audio: {str(e)}")
@@ -170,23 +182,83 @@ def get_processing_step_name(step):
     return steps[step]
 
 def process_text_file(file):
+    """Process uploaded text file"""
     try:
-        if file.name.endswith('.json'):
-            content = json.loads(file.read().decode())
-            transcript = extract_transcript_from_json(content)
-        elif file.name.endswith('.docx'):
-            doc = Document(file)
-            transcript = '\n'.join([paragraph.text for paragraph in doc.paragraphs])
-        else:
-            transcript = file.read().decode()
-            
-        if transcript:
-            st.session_state.current_transcript = transcript
-            analyze_session_content(transcript)
-            
+        # Read file content
+        content = file.getvalue().decode("utf-8")
+        st.session_state.current_transcript = content
+        
+        # Display transcript with edit option
+        edited_transcript = st.text_area(
+            "Review and edit transcript if needed:",
+            value=content,
+            height=300
+        )
+        
+        # Add analyze button
+        if st.button("Analyze Transcript"):
+            with st.spinner('Analyzing transcript...'):
+                st.session_state.current_transcript = edited_transcript
+                analyze_session_content(edited_transcript)
+                
     except Exception as e:
         st.error(f"Error processing file: {str(e)}")
 
+def parse_analysis_results(raw_results):
+    """Parse the raw analysis results into structured format"""
+    if isinstance(raw_results, dict):
+        return raw_results  # Already parsed
+    
+    try:
+        # If it's a string, try to extract structured data
+        analysis = {
+            'mi_adherence_score': 0,
+            'key_themes': [],
+            'technique_usage': {},
+            'strengths': [],
+            'areas_for_improvement': [],
+            'session_summary': ''
+        }
+        
+        # Extract score (assuming it's in format "Score: XX")
+        score_match = re.search(r'Score:\s*(\d+)', raw_results)
+        if score_match:
+            analysis['mi_adherence_score'] = int(score_match.group(1))
+        
+        # Extract themes (assuming they're listed after "Key Themes:")
+        themes_match = re.search(r'Key Themes:(.*?)(?=\n\n|\Z)', raw_results, re.DOTALL)
+        if themes_match:
+            themes = themes_match.group(1).strip().split('\n')
+            analysis['key_themes'] = [t.strip('- ') for t in themes if t.strip()]
+        
+        # Extract techniques (assuming they're listed with counts)
+        techniques = re.findall(r'(\w+\s*\w*)\s*:\s*(\d+)', raw_results)
+        if techniques:
+            analysis['technique_usage'] = {t[0]: int(t[1]) for t in techniques}
+        
+        # Extract strengths
+        strengths_match = re.search(r'Strengths:(.*?)(?=Areas for Improvement|\Z)', raw_results, re.DOTALL)
+        if strengths_match:
+            strengths = strengths_match.group(1).strip().split('\n')
+            analysis['strengths'] = [s.strip('- ') for s in strengths if s.strip()]
+        
+        # Extract areas for improvement
+        improvements_match = re.search(r'Areas for Improvement:(.*?)(?=\n\n|\Z)', raw_results, re.DOTALL)
+        if improvements_match:
+            improvements = improvements_match.group(1).strip().split('\n')
+            analysis['areas_for_improvement'] = [i.strip('- ') for i in improvements if i.strip()]
+        
+        # Extract summary
+        summary_match = re.search(r'Summary:(.*?)(?=\n\n|\Z)', raw_results, re.DOTALL)
+        if summary_match:
+            analysis['session_summary'] = summary_match.group(1).strip()
+        
+        return analysis
+        
+    except Exception as e:
+        st.error(f"Error parsing analysis results: {str(e)}")
+        return None
+        
 def show_manual_input_form():
     st.subheader("Session Details")
     
@@ -741,13 +813,16 @@ def analyze_session_content(transcript):
         st.error(f"Error analyzing session content: {str(e)}")
 
 def show_analysis_results():
-    """Display session analysis results"""
+    """Display the analysis results in the dashboard"""
     if not st.session_state.analysis_results:
-        st.warning("No analysis results available.")
         return
     
-    st.header("Session Analysis Results")
-    
+    # Parse the results
+    analysis = parse_analysis_results(st.session_state.analysis_results)
+    if not analysis:
+        st.error("Unable to parse analysis results")
+        return
+
     # Create tabs for different aspects of analysis
     tabs = st.tabs([
         "MI Adherence",
@@ -756,21 +831,174 @@ def show_analysis_results():
         "Session Flow",
         "Recommendations"
     ])
-    
-    # Parse analysis results (assuming structured response from AI)
-    analysis = parse_analysis_results(st.session_state.analysis_results)
-    
-    # Display results in respective tabs
+
+    # MI Adherence Tab
     with tabs[0]:
-        show_mi_adherence_analysis(analysis.get('mi_adherence', {}))
+        st.subheader("MI Adherence Score")
+        score = analysis.get('mi_adherence_score', 0)
+        create_gauge_chart(score)
+        
+        col1, col2 = st.columns(2)
+        with col1:
+            st.subheader("Strengths")
+            for strength in analysis.get('strengths', []):
+                st.markdown(f"✅ {strength}")
+        
+        with col2:
+            st.subheader("Areas for Improvement")
+            for area in analysis.get('areas_for_improvement', []):
+                st.markdown(f"🔄 {area}")
+
+    # Technical Skills Tab
     with tabs[1]:
-        show_technical_skills_analysis(analysis.get('technical_skills', {}))
+        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"
+            )
+            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))
+
+    # Client Language Tab
     with tabs[2]:
-        show_client_language_analysis(analysis.get('client_language', {}))
+        st.subheader("Client Language Analysis")
+        
+        # Create columns for different types of client language
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            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:
+            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")
+
+    # Session Flow Tab
     with tabs[3]:
-        show_session_flow_analysis(analysis.get('session_flow', {}))
+        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)
+        
+        # Add timeline visualization if available
+        if 'timeline' in analysis:
+            create_session_timeline(analysis['timeline'])
+
+    # Recommendations Tab
     with tabs[4]:
-        show_recommendations(analysis.get('recommendations', {}))
+        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)
+
+def get_technique_description(technique):
+    """Return description for MI techniques"""
+    descriptions = {
+        "Open Questions": "Questions that allow for elaboration and cannot be answered with a simple yes/no.",
+        "Reflections": "Statements that mirror, rephrase, or elaborate on the client's speech.",
+        "Affirmations": "Statements that recognize client strengths and acknowledge behaviors that lead to positive change.",
+        "Summaries": "Statements that collect, link, and transition between client statements.",
+        "Information Giving": "Providing information with permission and in response to client needs.",
+        # Add more techniques as needed
+    }
+    return descriptions.get(technique, "Description not available")
+
+def create_session_timeline(timeline_data):
+    """Create a visual timeline of the session"""
+    if not timeline_data:
+        st.info("Detailed timeline not available")
+        return
+    
+    fig = go.Figure()
+    # Add timeline visualization code here
+    st.plotly_chart(fig)
+
+def get_improvement_suggestion(area):
+    """Return specific suggestions for improvement areas"""
+    suggestions = {
+        "Open Questions": "Try replacing closed questions with open-ended ones. Instead of 'Did you exercise?', ask 'What kinds of physical activity have you been doing?'",
+        "Reflections": "Practice using more complex reflections by adding meaning or emotion to what the client has said.",
+        "Empathy": "Focus on seeing the situation from the client's perspective and verbalize your understanding.",
+        # Add more suggestions as needed
+    }
+    return suggestions.get(area, "Work on incorporating this element more intentionally in your sessions.")
+
+def create_action_items(analysis):
+    """Create specific action items based on analysis"""
+    st.write("Based on the analysis, consider focusing on these specific actions:")
+    
+    # Example action items
+    action_items = [
+        "Practice one new MI skill each session",
+        "Record and review your sessions",
+        "Focus on developing complex reflections",
+        "Track change talk/sustain talk ratio"
+    ]
+    
+    for item in action_items:
+        st.checkbox(item)
+
+def show_relevant_resources(analysis):
+    """Display relevant resources based on analysis"""
+    resources = [
+        {"title": "MI Practice Exercises", "url": "#"},
+        {"title": "Reflection Templates", "url": "#"},
+        {"title": "Change Talk Recognition Guide", "url": "#"},
+        {"title": "MI Community of Practice", "url": "#"}
+    ]
+    
+    for resource in resources:
+        st.markdown(f"[{resource['title']}]({resource['url']})")
+
 
 def parse_analysis_response(response_text):
     """Parse the AI response into structured analysis results"""