Create app.py

app.py

@@ -0,0 +1,216 @@
+import numpy as np
+import pandas as pd
+import gradio as gr
+import matplotlib.pyplot as plt
+import seaborn as sns
+from typing import Dict, List, Tuple
+
+class HealthStandards:
+    """Simplified health standards with error handling"""
+    
+    @staticmethod
+    def get_bmi_status(bmi: float) -> Dict:
+        try:
+            if bmi < 18.5:
+                return {"status": "Underweight", "risk": "High", 
+                       "recommendation": "Consult nutritionist for weight gain plan"}
+            elif bmi < 24.9:
+                return {"status": "Normal", "risk": "Low", 
+                       "recommendation": "Maintain healthy lifestyle"}
+            elif bmi < 29.9:
+                return {"status": "Overweight", "risk": "Moderate", 
+                       "recommendation": "Consider diet and exercise plan"}
+            else:
+                return {"status": "Obese", "risk": "High", 
+                       "recommendation": "Seek medical guidance"}
+        except Exception as e:
+            return {"status": "Error", "risk": "Unknown", 
+                   "recommendation": f"Error processing BMI: {str(e)}"}
+
+    @staticmethod
+    def get_bp_status(bp: float) -> Dict:
+        try:
+            if bp < 120:
+                return {"status": "Normal", "risk": "Low", 
+                       "recommendation": "Maintain healthy lifestyle"}
+            elif bp < 130:
+                return {"status": "Elevated", "risk": "Moderate", 
+                       "recommendation": "Monitor regularly"}
+            elif bp < 140:
+                return {"status": "Stage 1 Hypertension", "risk": "High", 
+                       "recommendation": "Consult healthcare provider"}
+            else:
+                return {"status": "Stage 2 Hypertension", "risk": "Very High", 
+                       "recommendation": "Immediate medical attention needed"}
+        except Exception as e:
+            return {"status": "Error", "risk": "Unknown", 
+                   "recommendation": f"Error processing blood pressure: {str(e)}"}
+
+    @staticmethod
+    def get_glucose_status(glucose: float) -> Dict:
+        try:
+            if glucose < 100:
+                return {"status": "Normal", "risk": "Low", 
+                       "recommendation": "Maintain healthy diet"}
+            elif glucose < 125:
+                return {"status": "Prediabetes", "risk": "Moderate", 
+                       "recommendation": "Lifestyle modifications needed"}
+            else:
+                return {"status": "Diabetes Range", "risk": "High", 
+                       "recommendation": "Consult healthcare provider"}
+        except Exception as e:
+            return {"status": "Error", "risk": "Unknown", 
+                   "recommendation": f"Error processing glucose: {str(e)}"}
+
+class HealthAnalyzer:
+    """Analyzes health metrics with error handling"""
+    
+    def __init__(self):
+        self.standards = HealthStandards()
+    
+    def analyze_metrics(self, age: float, bmi: float, bp: float, 
+                       glucose: float) -> Tuple[Dict, str]:
+        try:
+            # Get individual assessments
+            bmi_assessment = self.standards.get_bmi_status(bmi)
+            bp_assessment = self.standards.get_bp_status(bp)
+            glucose_assessment = self.standards.get_glucose_status(glucose)
+            
+            # Calculate risk score
+            risk_factors = 0
+            if bmi_assessment["risk"] in ["High", "Very High"]: risk_factors += 1
+            if bp_assessment["risk"] in ["High", "Very High"]: risk_factors += 1
+            if glucose_assessment["risk"] in ["High", "Very High"]: risk_factors += 1
+            if age > 60: risk_factors += 1
+            
+            risk_score = (risk_factors / 4) * 100
+            
+            analysis = {
+                "metrics": {
+                    "BMI": bmi_assessment,
+                    "Blood Pressure": bp_assessment,
+                    "Glucose": glucose_assessment
+                },
+                "risk_score": risk_score
+            }
+            
+            # Generate report
+            report = self.generate_report(analysis, age)
+            
+            return analysis, report
+            
+        except Exception as e:
+            return {"error": str(e)}, "Error occurred during analysis"
+
+    def generate_report(self, analysis: Dict, age: float) -> str:
+        try:
+            report = [
+                "=== HEALTH ANALYSIS REPORT ===\n",
+                f"Overall Risk Score: {analysis['risk_score']:.1f}%\n",
+                f"Risk Level: {self.get_risk_level(analysis['risk_score'])}\n",
+                "\nDetailed Analysis:"
+            ]
+            
+            for metric, assessment in analysis["metrics"].items():
+                report.extend([
+                    f"\n{metric}:",
+                    f"Status: {assessment['status']}",
+                    f"Risk Level: {assessment['risk']}",
+                    f"Recommendation: {assessment['recommendation']}"
+                ])
+            
+            return "\n".join(report)
+            
+        except Exception as e:
+            return f"Error generating report: {str(e)}"
+
+    @staticmethod
+    def get_risk_level(risk_score: float) -> str:
+        if risk_score < 33:
+            return "Low"
+        elif risk_score < 66:
+            return "Moderate"
+        else:
+            return "High"
+
+def create_visualization(analysis: Dict) -> plt.Figure:
+    """Create visualization with error handling"""
+    try:
+        sns.set_style("whitegrid")  # Use seaborn style directly
+        fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 5))
+        
+        # Metrics comparison
+        metrics = list(analysis["metrics"].keys())
+        risk_levels = [assessment["risk"] for assessment in analysis["metrics"].values()]
+        risk_values = [{"Low": 1, "Moderate": 2, "High": 3, "Very High": 4}.get(r, 0) 
+                      for r in risk_levels]
+        
+        colors = ['green' if r == "Low" else 'yellow' if r == "Moderate" 
+                 else 'red' for r in risk_levels]
+        
+        ax1.bar(metrics, risk_values, color=colors)
+        ax1.set_title("Health Metrics Risk Levels")
+        ax1.set_ylim(0, 4)
+        ax1.set_yticks([1, 2, 3, 4])
+        ax1.set_yticklabels(['Low', 'Moderate', 'High', 'Very High'])
+        
+        # Risk gauge
+        risk_score = analysis["risk_score"]
+        colors = ['green', 'yellow', 'red']
+        ax2.pie([risk_score, 100-risk_score], 
+                colors=[colors[int(risk_score/33.34)], 'lightgray'],
+                startangle=90, counterclock=False)
+        ax2.set_title(f"Overall Risk Score: {risk_score:.1f}%")
+        
+        plt.tight_layout()
+        return fig
+        
+    except Exception as e:
+        # Create error figure
+        fig, ax = plt.subplots(figsize=(8, 4))
+        ax.text(0.5, 0.5, f"Error creating visualization: {str(e)}", 
+                ha='center', va='center')
+        ax.axis('off')
+        return fig
+
+def analyze_health(age: float, bmi: float, bp: float, glucose: float) -> Tuple[plt.Figure, str]:
+    """Main analysis function with error handling"""
+    try:
+        analyzer = HealthAnalyzer()
+        analysis, report = analyzer.analyze_metrics(age, bmi, bp, glucose)
+        
+        if "error" in analysis:
+            raise Exception(analysis["error"])
+            
+        fig = create_visualization(analysis)
+        return fig, report
+        
+    except Exception as e:
+        error_fig, ax = plt.subplots(figsize=(8, 4))
+        ax.text(0.5, 0.5, f"Error: {str(e)}", ha='center', va='center')
+        ax.axis('off')
+        return error_fig, f"An error occurred: {str(e)}"
+
+# Create Gradio interface
+def create_gradio_interface():
+    interface = gr.Interface(
+        fn=analyze_health,
+        inputs=[
+            gr.Slider(20, 90, value=50, label="Age"),
+            gr.Slider(15, 45, value=25, label="BMI"),
+            gr.Slider(80, 200, value=120, label="Blood Pressure"),
+            gr.Slider(70, 200, value=100, label="Glucose")
+        ],
+        outputs=[
+            gr.Plot(label="Health Analysis Dashboard"),
+            gr.Textbox(label="Health Report", lines=10)
+        ],
+        title="Health Analysis System",
+        description="Enter patient metrics for health analysis."
+    )
+    return interface
+
+if __name__ == "__main__":
+    # Launch the Gradio interface
+    interface = create_gradio_interface()
+    interface.launch()