Upload simple_casl_app.py

simple_casl_app.py

@@ -107,7 +107,7 @@ else:
     logger.warning("Claude API key not found - using demo mode")
 
 def validate_analysis_completeness(response_text):
-    """Validate that all 12 sections are present in the analysis"""
+    """Validate that all 12 sections are present in the analysis exactly once"""
     required_sections = [
         "1. SPEECH FACTORS",
         "2. LANGUAGE SKILLS ASSESSMENT", 
@@ -124,25 +124,129 @@ def validate_analysis_completeness(response_text):
     ]
     
     missing_sections = []
+    duplicate_sections = []
+    section_counts = {}
+    
     for section in required_sections:
-        if section not in response_text:
+        count = response_text.count(section)
+        section_counts[section] = count
+        if count == 0:
             missing_sections.append(section)
+        elif count > 1:
+            duplicate_sections.append(section)
+    
+    # Log detailed validation results
+    print(f"\n=== COMPREHENSIVE VALIDATION ===")
+    print(f"Total response length: {len(response_text)} characters")
+    print(f"Missing sections: {missing_sections}")
+    print(f"Duplicate sections: {duplicate_sections}")
+    print(f"Section counts: {section_counts}")
     
     if missing_sections:
         print(f"\n⚠️  MISSING SECTIONS: {missing_sections}")
-        return False
+        return False, missing_sections, duplicate_sections, section_counts
+    elif duplicate_sections:
+        print(f"\n⚠️  DUPLICATE SECTIONS: {duplicate_sections}")
+        return False, missing_sections, duplicate_sections, section_counts
     else:
-        print(f"\n✅ ALL 12 SECTIONS PRESENT")
-        return True
+        print(f"\n✅ ALL 12 SECTIONS PRESENT EXACTLY ONCE")
+        return True, missing_sections, duplicate_sections, section_counts
+
+def fix_incomplete_analysis(response_text, missing_sections):
+    """Attempt to fix incomplete analysis by requesting missing sections"""
+    if not missing_sections:
+        return response_text
+    
+    if not ANTHROPIC_API_KEY:
+        return response_text + "\n\n❌ Cannot fix incomplete analysis - API key not configured"
+    
+    try:
+        # Create a focused prompt for missing sections
+        missing_sections_text = "\n".join([f"- {section}" for section in missing_sections])
+        
+        fix_prompt = f"""
+The following sections are missing from the CASL analysis. Please provide ONLY these missing sections:
+
+{missing_sections_text}
+
+IMPORTANT: 
+- Provide ONLY the missing sections listed above
+- Do not repeat any sections that are already present
+- Use the exact section headers as shown above
+- Make each section comprehensive and detailed
+- Ensure clinical accuracy and appropriate depth for SLP assessment
+"""
+        
+        headers = {
+            "Content-Type": "application/json",
+            "x-api-key": ANTHROPIC_API_KEY,
+            "anthropic-version": "2023-06-01"
+        }
+        
+        data = {
+            "model": "claude-3-5-sonnet-20241022",
+            "max_tokens": 4096,
+            "messages": [
+                {
+                    "role": "user",
+                    "content": fix_prompt
+                }
+            ]
+        }
+        
+        response = requests.post(
+            "https://api.anthropic.com/v1/messages",
+            headers=headers,
+            json=data,
+            timeout=90
+        )
+        
+        if response.status_code == 200:
+            response_json = response.json()
+            fix_text = response_json['content'][0]['text']
+            
+            # Combine original response with fix
+            complete_response = response_text + "\n\n" + fix_text
+            
+            print(f"\n=== FIXED INCOMPLETE ANALYSIS ===")
+            print(f"Added missing sections: {missing_sections}")
+            print(f"Fix text length: {len(fix_text)} characters")
+            print("=" * 50)
+            
+            return complete_response
+        else:
+            logger.error(f"Error fixing incomplete analysis: {response.status_code}")
+            return response_text + f"\n\n❌ Error fixing incomplete analysis: {response.status_code}"
+            
+    except Exception as e:
+        logger.error(f"Error in fix_incomplete_analysis: {str(e)}")
+        return response_text + f"\n\n❌ Error fixing incomplete analysis: {str(e)}"
 
 def call_claude_api_with_continuation(prompt, max_continuations=3):
     """Call Claude API with continuation prompting to ensure complete responses"""
     if not ANTHROPIC_API_KEY:
         return "❌ Claude API key not configured. Please set ANTHROPIC_API_KEY environment variable."
     
+    # Define all required sections
+    required_sections = [
+        "1. SPEECH FACTORS",
+        "2. LANGUAGE SKILLS ASSESSMENT", 
+        "3. COMPLEX SENTENCE ANALYSIS",
+        "4. FIGURATIVE LANGUAGE ANALYSIS",
+        "5. PRAGMATIC LANGUAGE ASSESSMENT",
+        "6. VOCABULARY AND SEMANTIC ANALYSIS",
+        "7. MORPHOLOGICAL AND PHONOLOGICAL ANALYSIS",
+        "8. COGNITIVE-LINGUISTIC FACTORS",
+        "9. FLUENCY AND RHYTHM ANALYSIS",
+        "10. QUANTITATIVE METRICS",
+        "11. CLINICAL IMPLICATIONS",
+        "12. PROGNOSIS AND SUMMARY"
+    ]
+    
     try:
-        full_response = ""
+        response_parts = []  # Store each part as a separate item
         continuation_count = 0
+        completed_sections = set()  # Track which sections have been completed
         
         # Add continuation instruction to original prompt
         initial_prompt = prompt + "\n\nIMPORTANT: If your response is cut off or incomplete, end with <CONTINUE> to indicate more content is needed. Ensure you complete all sections of the analysis."
@@ -190,29 +294,28 @@ def call_claude_api_with_continuation(prompt, max_continuations=3):
                 print(f"Last 200 chars: {response_text[-200:]}...")
                 print("=" * 50)
                 
-                # Simple string combination - no complex processing
-                if continuation_count == 0:
-                    full_response = response_text
-                else:
-                    # Just add a newline and append the continuation
-                    full_response += "\n\n" + response_text
+                # Store this part
+                response_parts.append(response_text)
+                
+                # Check which sections are present in this part
+                for section in required_sections:
+                    if section in response_text:
+                        completed_sections.add(section)
                 
                 # Check if response indicates continuation is needed
                 needs_continuation = "<CONTINUE>" in response_text
                 
                 print(f"Needs continuation: {needs_continuation}")
                 print(f"Continuation count: {continuation_count}/{max_continuations}")
+                print(f"Completed sections: {len(completed_sections)}/12")
+                print(f"Missing sections: {[s for s in required_sections if s not in completed_sections]}")
                 
                 # Continue if <CONTINUE> is present and we haven't reached max
                 if needs_continuation and continuation_count < max_continuations:
-                    # Remove the CONTINUE marker
-                    full_response = full_response.replace("<CONTINUE>", "")
                     continuation_count += 1
                     logger.info(f"Continuing analysis (attempt {continuation_count}/{max_continuations})")
                     continue
                 else:
-                    # Clean up any remaining continuation markers
-                    full_response = full_response.replace("<CONTINUE>", "")
                     break
             else:
                 logger.error(f"Claude API error: {response.status_code} - {response.text}")
@@ -222,16 +325,36 @@ def call_claude_api_with_continuation(prompt, max_continuations=3):
         logger.error(f"Error calling Claude API: {str(e)}")
         return f"❌ Error: {str(e)}"
     
-    # Add completion indicator
-    if continuation_count > 0:
-        full_response += f"\n\n[Analysis completed in {continuation_count + 1} parts]"
+    # Combine all parts and clean up
+    full_response = "\n\n".join(response_parts)
+    full_response = full_response.replace("<CONTINUE>", "")
+    
+    # Validate completeness
+    missing_sections = []
+    duplicate_sections = []
+    section_counts = {}
     
-    # Log final response for debugging
-    print(f"\n=== FINAL COMPLETE RESPONSE ===")
-    print(f"Total length: {len(full_response)} characters")
-    print(f"Number of parts: {continuation_count + 1}")
+    for section in required_sections:
+        count = full_response.count(section)
+        section_counts[section] = count
+        if count == 0:
+            missing_sections.append(section)
+        elif count > 1:
+            duplicate_sections.append(section)
+    
+    # Log validation results
+    print(f"\n=== VALIDATION RESULTS ===")
+    print(f"Total response length: {len(full_response)} characters")
+    print(f"Number of parts: {len(response_parts)}")
+    print(f"Missing sections: {missing_sections}")
+    print(f"Duplicate sections: {duplicate_sections}")
+    print(f"Section counts: {section_counts}")
     print("=" * 50)
     
+    # Add completion indicator
+    if len(response_parts) > 1:
+        full_response += f"\n\n[Analysis completed in {len(response_parts)} parts]"
+    
     # Print the entire final response for debugging
     print(f"\n=== ENTIRE FINAL RESPONSE ===")
     print(full_response)
@@ -750,6 +873,30 @@ def analyze_transcript_content(transcript_content, age, gender, slp_notes):
     
     # Get analysis from Claude API
     result = call_claude_api_with_continuation(prompt, max_continuations=5)
+    
+    # Validate completeness and fix if needed
+    is_complete, missing_sections, duplicate_sections, section_counts = validate_analysis_completeness(result)
+    
+    if not is_complete:
+        print(f"\n🔧 ATTEMPTING TO FIX INCOMPLETE ANALYSIS...")
+        print(f"Missing sections: {missing_sections}")
+        print(f"Duplicate sections: {duplicate_sections}")
+        
+        # Try to fix missing sections
+        if missing_sections:
+            result = fix_incomplete_analysis(result, missing_sections)
+            
+            # Re-validate after fix
+            is_complete_after_fix, missing_after_fix, duplicate_after_fix, counts_after_fix = validate_analysis_completeness(result)
+            
+            if not is_complete_after_fix:
+                print(f"\n⚠️  ANALYSIS STILL INCOMPLETE AFTER FIX ATTEMPT")
+                print(f"Still missing: {missing_after_fix}")
+                print(f"Still duplicate: {duplicate_after_fix}")
+                result += f"\n\n⚠️  WARNING: Analysis may be incomplete. Missing sections: {missing_after_fix}"
+            else:
+                print(f"\n✅ ANALYSIS FIXED SUCCESSFULLY")
+    
     return result
 
 def analyze_transcript(file, age, gender, slp_notes):
@@ -874,6 +1021,14 @@ def targeted_analysis(transcript, custom_question, age, gender, slp_notes):
     
     # Get targeted analysis from Claude API
     result = call_claude_api_with_continuation(prompt, max_continuations=3)
+    
+    # For targeted analysis, we don't need the full 12-section validation
+    # but we can still validate that the response is complete and well-structured
+    if len(result.strip()) < 500:  # Basic length check
+        print(f"\n⚠️  TARGETED ANALYSIS MAY BE INCOMPLETE")
+        print(f"Response length: {len(result)} characters")
+        result += f"\n\n⚠️  WARNING: This targeted analysis may be incomplete. Please review the results carefully."
+    
     return result
 
 # Create enhanced interface with tabs
@@ -1312,6 +1467,20 @@ with gr.Blocks(title="Enhanced CASL Analysis", theme=gr.themes.Soft()) as app:
         """
         
         result = call_claude_api_with_continuation(prompt, max_continuations=2)
+        
+        # For quick analysis, validate that all selected questions were addressed
+        if questions and len(questions) > 0:
+            missing_questions = []
+            for question in questions:
+                # Check if the question was addressed (basic check)
+                if question.lower() not in result.lower():
+                    missing_questions.append(question)
+            
+            if missing_questions:
+                print(f"\n⚠️  QUICK ANALYSIS MAY BE INCOMPLETE")
+                print(f"Missing questions: {missing_questions}")
+                result += f"\n\n⚠️  WARNING: Some selected questions may not have been fully addressed: {missing_questions}"
+        
         progress_msg = "✅ Quick analysis completed" if "[Analysis completed in" in result else "🔄 Quick analysis in progress..."
         return result, progress_msg