Update session_analysis.py

session_analysis.py

@@ -1,5 +1,4 @@
 import streamlit as st
-from google.cloud import speech_v1
 import io
 import pandas as pd
 import plotly.express as px
@@ -66,20 +65,40 @@ def process_media_file(file, type):
     progress_bar = st.progress(0)
     
     try:
-        # Convert file to audio if needed
-        if type == "Video Recording":
-            status.text("Converting video to audio...")
-            progress_bar.progress(20)
-            # Add video to audio conversion here if needed
-            audio_content = convert_video_to_audio(file)
-        else:
-            audio_content = file.read()
-
-        # Generate transcript
+        # Read file content
+        file_content = file.read()
+        
         status.text("Generating transcript...")
-        progress_bar.progress(60)
+        progress_bar.progress(50)
         
-        transcript = generate_transcript(audio_content)
+        # Generate transcript using Gemini
+        model = genai.GenerativeModel('gemini-pro')
+        
+        # Convert file content to text
+        if type == "Audio Recording":
+            # For audio files, create a prompt that describes the audio
+            prompt = f"""
+            This is an audio recording of a therapy session.
+            Please transcribe the conversation and include speaker labels where possible.
+            Focus on capturing:
+            1. The therapist's questions and reflections
+            2. The client's responses and statements
+            3. Any significant pauses or non-verbal sounds
+            """
+        else:  # Video Recording
+            # For video files, create a prompt that describes the video
+            prompt = f"""
+            This is a video recording of a therapy session.
+            Please transcribe the conversation and include:
+            1. Speaker labels
+            2. Verbal communication
+            3. Relevant non-verbal cues and body language
+            4. Significant pauses or interactions
+            """
+            
+        # Generate transcript
+        response = model.generate_content(prompt)
+        transcript = response.text
         
         if transcript:
             st.session_state.current_transcript = transcript
@@ -97,6 +116,7 @@ def process_media_file(file, type):
         progress_bar.empty()
 
 
+
 def get_processing_step_name(step):
     steps = [
         "Loading media file",
@@ -128,39 +148,49 @@ def process_text_file(file):
 def show_manual_input_form():
     st.subheader("Session Details")
     
-    # Session metadata
-    session_date = st.date_input("Session Date", datetime.now())
-    session_duration = st.number_input("Session Duration (minutes)", min_value=1, max_value=180, value=50)
-    
-    # Client information
-    client_id = st.text_input("Client ID (optional)")
-    session_number = st.number_input("Session Number", min_value=1, value=1)
-    
-    # Session content
-    session_notes = st.text_area(
-        "Session Notes",
-        height=300,
-        help="Enter detailed session notes including key dialogues, interventions, and observations"
-    )
-    
-    # Target behaviors
-    target_behaviors = st.text_area(
-        "Target Behaviors/Goals",
-        height=100,
-        help="Enter the specific behaviors or goals discussed in the session"
-    )
-    
-    # MI specific elements
-    st.subheader("MI Elements")
-    change_talk = st.text_area("Observed Change Talk")
-    sustain_talk = st.text_area("Observed Sustain Talk")
-    
-    if st.button("Analyze Session"):
-        session_data = compile_session_data(
-            session_date, session_duration, client_id, session_number,
-            session_notes, target_behaviors, change_talk, sustain_talk
+    with st.form("session_notes_form"):
+        # Basic session information
+        session_date = st.date_input("Session Date", datetime.now())
+        session_duration = st.number_input("Duration (minutes)", min_value=15, max_value=120, value=50)
+        
+        # Session content
+        session_notes = st.text_area(
+            "Session Notes",
+            height=300,
+            placeholder="Enter detailed session notes here..."
+        )
+        
+        # Key themes and observations
+        key_themes = st.text_area(
+            "Key Themes",
+            height=100,
+            placeholder="Enter key themes identified during the session..."
         )
-        analyze_session_content(session_data)
+        
+        # MI specific elements
+        mi_techniques_used = st.multiselect(
+            "MI Techniques Used",
+            ["Open Questions", "Affirmations", "Reflections", "Summaries", 
+             "Change Talk", "Commitment Language", "Planning"]
+        )
+        
+        # Submit button
+        submitted = st.form_submit_button("Analyze Session")
+        
+        if submitted and session_notes:
+            # Combine all input into a structured format
+            session_data = {
+                'date': session_date,
+                'duration': session_duration,
+                'notes': session_notes,
+                'themes': key_themes,
+                'techniques': mi_techniques_used
+            }
+            
+            # Process the session data
+            st.session_state.current_transcript = format_session_data(session_data)
+            analyze_session_content(st.session_state.current_transcript)
+
 
 def analyze_session_content(content):
     try:
@@ -466,7 +496,6 @@ def show_oars_chart(oars_metrics):
     
     st.plotly_chart(fig)
 
-# Add more visualization functions as needed...
 
 def save_analysis_results():
     """Save analysis results to file"""
@@ -483,6 +512,42 @@ def save_analysis_results():
         except Exception as e:
             st.error(f"Error saving analysis results: {str(e)}")
 
+def show_upload_section():
+    st.header("Session Data Upload")
+    
+    upload_type = st.radio(
+        "Select Input Method:",
+        ["Text Transcript", "Session Notes", "Previous Session Data"]  # Removed Audio/Video options
+    )
+    
+    if upload_type == "Text Transcript":
+        file = st.file_uploader("Upload Transcript", type=["txt", "doc", "docx", "json"])
+        if file:
+            process_text_file(file)
+            
+    elif upload_type == "Session Notes":
+        show_manual_input_form()
+        
+    else:  # Previous Session Data
+        show_previous_sessions_selector()
+
+def process_text_file(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)
+            
+    except Exception as e:
+        st.error(f"Error processing file: {str(e)}")
 def show_export_options():
     st.sidebar.subheader("Export Options")
     
@@ -559,52 +624,6 @@ def load_previous_sessions():
         st.error(f"Error loading previous sessions: {str(e)}")
         return []
 
-def show_manual_input_form():
-    """Display form for manual session notes input"""
-    st.subheader("Session Notes Input")
-    
-    with st.form("session_notes_form"):
-        # Basic session information
-        session_date = st.date_input("Session Date", datetime.now())
-        session_duration = st.number_input("Duration (minutes)", min_value=15, max_value=120, value=50)
-        
-        # Session content
-        session_notes = st.text_area(
-            "Session Notes",
-            height=300,
-            placeholder="Enter detailed session notes here..."
-        )
-        
-        # Key themes and observations
-        key_themes = st.text_area(
-            "Key Themes",
-            height=100,
-            placeholder="Enter key themes identified during the session..."
-        )
-        
-        # MI specific elements
-        mi_techniques_used = st.multiselect(
-            "MI Techniques Used",
-            ["Open Questions", "Affirmations", "Reflections", "Summaries", 
-             "Change Talk", "Commitment Language", "Planning"]
-        )
-        
-        # Submit button
-        submitted = st.form_submit_button("Analyze Session")
-        
-        if submitted and session_notes:
-            # Combine all input into a structured format
-            session_data = {
-                'date': session_date,
-                'duration': session_duration,
-                'notes': session_notes,
-                'themes': key_themes,
-                'techniques': mi_techniques_used
-            }
-            
-            # Process the session data
-            st.session_state.current_transcript = format_session_data(session_data)
-            analyze_session_content(st.session_state.current_transcript)
 
 def format_session_data(session_data):
     """Format session data into analyzable transcript"""
@@ -624,20 +643,29 @@ def format_session_data(session_data):
     return formatted_text
 
 def analyze_session_content(transcript):
-    """Analyze session content using Gemini AI"""
     try:
-        # Configure Gemini model
+        # Initialize Gemini
         model = genai.GenerativeModel('gemini-pro')
         
-        # Prepare analysis prompt
-        analysis_prompt = SESSION_EVALUATION_PROMPT + f"\nTranscript:\n{transcript}"
+        # Prepare the analysis prompt
+        analysis_prompt = f"""
+        {MI_SYSTEM_PROMPT}
+        
+        Please analyze the following therapy session transcript:
+        
+        {transcript}
+        
+        {SESSION_EVALUATION_PROMPT}
+        """
         
         # Generate analysis
         response = model.generate_content(analysis_prompt)
         
-        # Store and display results
-        st.session_state.analysis_results = response.text
-        show_analysis_results()
+        # Parse the response
+        analysis_results = parse_analysis_response(response.text)
+        
+        # Store results in session state
+        st.session_state.analysis_results = analysis_results
         
     except Exception as e:
         st.error(f"Error analyzing session content: {str(e)}")
@@ -674,20 +702,111 @@ def show_analysis_results():
     with tabs[4]:
         show_recommendations(analysis.get('recommendations', {}))
 
-def parse_analysis_results(results_text):
-    """Parse the AI analysis results into structured format"""
-    # This is a placeholder for more sophisticated parsing
-    # In a real implementation, you'd want to parse the AI response
-    # into a structured format based on your specific needs
+def parse_analysis_response(response_text):
+    """Parse the AI response into structured analysis results"""
+    try:
+        # Initialize default structure for analysis results
+        analysis = {
+            'mi_adherence_score': 0.0,
+            'key_themes': [],
+            'technique_usage': {},
+            'strengths': [],
+            'areas_for_improvement': [],
+            'recommendations': [],
+            'change_talk_instances': [],
+            'session_summary': ""
+        }
+        
+        # Extract MI adherence score
+        score_match = re.search(r'MI Adherence Score:\s*(\d+\.?\d*)', response_text)
+        if score_match:
+            analysis['mi_adherence_score'] = float(score_match.group(1))
+        
+        # Extract key themes
+        themes_section = re.search(r'Key Themes:(.*?)(?=\n\n|\Z)', response_text, re.DOTALL)
+        if themes_section:
+            themes = themes_section.group(1).strip().split('\n')
+            analysis['key_themes'] = [theme.strip('- ') for theme in themes if theme.strip()]
+        
+        # Extract technique usage
+        technique_section = re.search(r'Technique Usage:(.*?)(?=\n\n|\Z)', response_text, re.DOTALL)
+        if technique_section:
+            techniques = technique_section.group(1).strip().split('\n')
+            for technique in techniques:
+                if ':' in technique:
+                    name, count = technique.split(':')
+                    analysis['technique_usage'][name.strip()] = int(count.strip())
+        
+        # Extract strengths
+        strengths_section = re.search(r'Strengths:(.*?)(?=\n\n|\Z)', response_text, re.DOTALL)
+        if strengths_section:
+            strengths = strengths_section.group(1).strip().split('\n')
+            analysis['strengths'] = [s.strip('- ') for s in strengths if s.strip()]
+        
+        # Extract areas for improvement
+        improvements_section = re.search(r'Areas for Improvement:(.*?)(?=\n\n|\Z)', response_text, re.DOTALL)
+        if improvements_section:
+            improvements = improvements_section.group(1).strip().split('\n')
+            analysis['areas_for_improvement'] = [i.strip('- ') for i in improvements if i.strip()]
+        
+        # Extract session summary
+        summary_section = re.search(r'Session Summary:(.*?)(?=\n\n|\Z)', response_text, re.DOTALL)
+        if summary_section:
+            analysis['session_summary'] = summary_section.group(1).strip()
+        
+        return analysis
+        
+    except Exception as e:
+        st.error(f"Error parsing analysis response: {str(e)}")
+        return None
+
+def create_gauge_chart(score):
+    """Create a gauge chart for MI Adherence Score"""
+    fig = go.Figure(go.Indicator(
+        mode = "gauge+number",
+        value = score,
+        domain = {'x': [0, 1], 'y': [0, 1]},
+        title = {'text': "MI Adherence"},
+        gauge = {
+            'axis': {'range': [0, 100]},
+            'bar': {'color': "darkblue"},
+            'steps': [
+                {'range': [0, 40], 'color': "lightgray"},
+                {'range': [40, 70], 'color': "gray"},
+                {'range': [70, 100], 'color': "darkgray"}
+            ],
+            'threshold': {
+                'line': {'color': "red", 'width': 4},
+                'thickness': 0.75,
+                'value': 90
+            }
+        }
+    ))
     
-    return {
-        'mi_adherence': {'raw_text': results_text},
-        'technical_skills': {'raw_text': results_text},
-        'client_language': {'raw_text': results_text},
-        'session_flow': {'raw_text': results_text},
-        'recommendations': {'raw_text': results_text}
-    }
+    st.plotly_chart(fig)
+
+def create_technique_usage_chart(technique_usage):
+    """Create a bar chart for MI technique usage"""
+    df = pd.DataFrame(list(technique_usage.items()), columns=['Technique', 'Count'])
+    fig = px.bar(
+        df,
+        x='Technique',
+        y='Count',
+        title='MI Technique Usage Frequency'
+    )
+    fig.update_layout(
+        xaxis_title="Technique",
+        yaxis_title="Frequency",
+        showlegend=False
+    )
+    st.plotly_chart(fig)
 
+def extract_transcript_from_json(content):
+    """Extract transcript from JSON content"""
+    if isinstance(content, dict):
+        return json.dumps(content, indent=2)
+    return str(content)
+    
 # Analysis display functions
 def show_mi_adherence_analysis(analysis):
     st.subheader("MI Adherence Analysis")