Create symptom_analyzer.py

utils/symptom_analyzer.py

@@ -0,0 +1,218 @@
+"""
+Advanced symptom analyzer for homeopathic case analysis
+"""
+import re
+from typing import Dict, List, Tuple
+import spacy
+try:
+    nlp = spacy.load("en_core_web_sm")
+except:
+    # Fallback if spaCy not installed
+    nlp = None
+
+class SymptomAnalyzer:
+    def __init__(self):
+        self.symptom_categories = {
+            'location': ['head', 'stomach', 'throat', 'chest', 'back', 'limbs', 'joints'],
+            'sensation': ['burning', 'throbbing', 'stabbing', 'aching', 'pressing', 'shooting'],
+            'modality': ['worse', 'better', 'aggravated', 'ameliorated', 'increased', 'decreased'],
+            'time': ['morning', 'evening', 'night', 'afternoon', 'midnight', 'dawn'],
+            'emotional': ['anxious', 'fearful', 'irritable', 'sad', 'restless', 'apathetic']
+        }
+    
+    def analyze_case_sheet(self, case_data: Dict) -> Dict:
+        """Comprehensive analysis of case sheet data"""
+        analysis = {
+            'physical_symptoms': self._extract_physical_symptoms(case_data.get('symptoms', '')),
+            'modalities': self._extract_modalities(case_data.get('modalities', '')),
+            'time_factors': self._extract_time_factors(case_data.get('timing', '')),
+            'emotional_state': self._analyze_emotional_state(case_data.get('emotional_state', '')),
+            'constitutional_factors': self._analyze_constitutional(case_data.get('constitutional', '')),
+            'key_symptoms': [],
+            'strange_rare_peculiar': []
+        }
+        
+        # Identify key symptoms
+        analysis['key_symptoms'] = self._identify_key_symptoms(analysis)
+        
+        # Identify strange, rare, peculiar symptoms
+        analysis['strange_rare_peculiar'] = self._identify_srp(analysis)
+        
+        return analysis
+    
+    def _extract_physical_symptoms(self, text: str) -> List[Dict]:
+        """Extract physical symptoms with details"""
+        symptoms = []
+        
+        # Simple pattern matching (can be enhanced with NLP)
+        patterns = {
+            'pain': r'(pain|ache|sore|tenderness)(?:\s+(?:in|of|at)\s+(\w+))?',
+            'fever': r'(fever|temperature|hot|cold|chill)',
+            'digestive': r'(nausea|vomiting|diarrhea|constipation|bloating|indigestion)',
+            'respiratory': r'(cough|breath|sneeze|nasal|throat)',
+            'skin': r'(rash|itch|redness|swelling|eruption)'
+        }
+        
+        for symptom_type, pattern in patterns.items():
+            matches = re.finditer(pattern, text.lower())
+            for match in matches:
+                symptoms.append({
+                    'type': symptom_type,
+                    'description': match.group(),
+                    'location': match.group(2) if match.lastindex > 1 else 'general'
+                })
+        
+        return symptoms
+    
+    def _extract_modalities(self, text: str) -> Dict:
+        """Extract what makes symptoms better or worse"""
+        modalities = {
+            'aggravations': [],
+            'ameliorations': []
+        }
+        
+        # Look for worsening factors
+        worse_patterns = [
+            r'worse\s+(?:with|from|after|by)\s+([^.]+)',
+            r'aggravated\s+by\s+([^.]+)',
+            r'increased\s+with\s+([^.]+)'
+        ]
+        
+        for pattern in worse_patterns:
+            matches = re.findall(pattern, text.lower())
+            for match in matches:
+                modalities['aggravations'].extend([m.strip() for m in match.split(',')])
+        
+        # Look for improving factors
+        better_patterns = [
+            r'better\s+(?:with|from|after|by)\s+([^.]+)',
+            r'relieved\s+by\s+([^.]+)',
+            r'ameliorated\s+by\s+([^.]+)'
+        ]
+        
+        for pattern in better_patterns:
+            matches = re.findall(pattern, text.lower())
+            for match in matches:
+                modalities['ameliorations'].extend([m.strip() for m in match.split(',')])
+        
+        return modalities
+    
+    def _extract_time_factors(self, text: str) -> Dict:
+        """Extract time-related factors"""
+        time_factors = {
+            'time_of_day': [],
+            'periodicity': [],
+            'duration': []
+        }
+        
+        # Time of day patterns
+        time_patterns = {
+            'morning': r'\b(morning|dawn|sunrise|AM)\b',
+            'afternoon': r'\b(afternoon|midday|noon|2pm|3pm)\b',
+            'evening': r'\b(evening|dusk|sunset|PM)\b',
+            'night': r'\b(night|midnight|2am|3am)\b'
+        }
+        
+        for time_name, pattern in time_patterns.items():
+            if re.search(pattern, text.lower()):
+                time_factors['time_of_day'].append(time_name)
+        
+        # Periodicity
+        if re.search(r'\b(every\s+\w+|daily|weekly|monthly|periodic)\b', text.lower()):
+            time_factors['periodicity'].append('periodic')
+        
+        return time_factors
+    
+    def _analyze_emotional_state(self, text: str) -> Dict:
+        """Analyze emotional and mental state"""
+        emotions = {
+            'fear': ['fear', 'anxious', 'worried', 'apprehensive', 'panic'],
+            'anger': ['angry', 'irritable', 'frustrated', 'resentful'],
+            'sadness': ['sad', 'depressed', 'weepy', 'grief', 'melancholy'],
+            'restlessness': ['restless', 'agitated', 'nervous', 'fidgety']
+        }
+        
+        detected = []
+        for emotion, keywords in emotions.items():
+            if any(keyword in text.lower() for keyword in keywords):
+                detected.append(emotion)
+        
+        return {
+            'primary_emotions': detected,
+            'description': text
+        }
+    
+    def _analyze_constitutional(self, text: str) -> Dict:
+        """Analyze constitutional factors"""
+        factors = {
+            'thermals': self._extract_thermals(text),
+            'desires_aversions': self._extract_desires_aversions(text),
+            'generalities': []
+        }
+        
+        # General constitutional factors
+        general_terms = ['weak', 'strong', 'lean', 'stout', 'pale', 'flushed']
+        for term in general_terms:
+            if term in text.lower():
+                factors['generalities'].append(term)
+        
+        return factors
+    
+    def _extract_thermals(self, text: str) -> List[str]:
+        """Extract thermal preferences"""
+        thermals = []
+        if 'warm' in text.lower() or 'heat' in text.lower():
+            thermals.append('warm-blooded')
+        if 'cold' in text.lower() or 'chilly' in text.lower():
+            thermals.append('cold-blooded')
+        return thermals
+    
+    def _extract_desires_aversions(self, text: str) -> Dict:
+        """Extract food desires and aversions"""
+        desires = []
+        aversions = []
+        
+        # Simple pattern matching
+        desire_pattern = r'desires?\s+(?:to\s+)?(\w+)'
+        aversion_pattern = r'aversions?\s+(?:to\s+)?(\w+)'
+        
+        desires.extend(re.findall(desire_pattern, text.lower()))
+        aversions.extend(re.findall(aversion_pattern, text.lower()))
+        
+        return {'desires': desires, 'aversions': aversions}
+    
+    def _identify_key_symptoms(self, analysis: Dict) -> List[str]:
+        """Identify key symptoms for repertorization"""
+        key_symptoms = []
+        
+        # Add strong modalities
+        if analysis['modalities']['aggravations']:
+            key_symptoms.append(f"< aggravations: {', '.join(analysis['modalities']['aggravations'][:3])}")
+        if analysis['modalities']['ameliorations']:
+            key_symptoms.append(f"> ameliorations: {', '.join(analysis['modalities']['ameliorations'][:3])}")
+        
+        # Add time factors
+        if analysis['time_factors']['time_of_day']:
+            key_symptoms.append(f"time: {', '.join(analysis['time_factors']['time_of_day'])}")
+        
+        # Add emotional state
+        if analysis['emotional_state']['primary_emotions']:
+            key_symptoms.append(f"emotion: {', '.join(analysis['emotional_state']['primary_emotions'])}")
+        
+        return key_symptoms
+    
+    def _identify_srp(self, analysis: Dict) -> List[str]:
+        """Identify strange, rare, peculiar symptoms"""
+        srp_symptoms = []
+        
+        # Look for unusual modalities
+        unusual_modalities = ['contradictory', 'paradoxical', 'opposite', 'strange']
+        for modality in analysis['modalities']['aggravations'] + analysis['modalities']['ameliorations']:
+            if any(word in modality for word in unusual_modalities):
+                srp_symptoms.append(f"Unusual modality: {modality}")
+        
+        # Look for contradictory symptoms
+        if analysis['emotional_state']['primary_emotions'] and len(analysis['emotional_state']['primary_emotions']) > 1:
+            srp_symptoms.append(f"Contradictory emotions: {', '.join(analysis['emotional_state']['primary_emotions'])}")
+        
+        return srp_symptoms