Update backend_app.py

backend_app.py

@@ -648,27 +648,26 @@ class MedicalReportAnalyzer:
                     "abnormal_count": len(abnormal_parameters)
                 }
             else:
-                    #Create a minimal report with error message
-                    report_id = str(uuid.uuid4())
-                    report = MedicalReport(
-                        report_id=report_id,
-                        report_text="Unable to extract text from the provided PDF. This is an empty report placeholder.",
-                        report_name="Error Report"
-                    )
-                    self.reports[report_id] = report
-                    self.current_report_id = report_id
+                # Create a minimal report with error message
+                report_id = str(uuid.uuid4())
+                report = MedicalReport(
+                    report_id=report_id,
+                    report_text="Unable to extract text from the provided PDF. This is an empty report placeholder.",
+                    report_name="Error Report"
+                )
+                self.reports[report_id] = report
+                self.current_report_id = report_id
 
-                    return {
-                        "status": "error",
-                        "message": "Warning: Could not extract text from the PDF. The file may be corrupted, password-protected, or contain only images.",
-                        "report_id": report_id
-                    }
+                return {
+                    "status": "error",
+                    "message": "Warning: Could not extract text from the PDF. The file may be corrupted, password-protected, or contain only images.",
+                    "report_id": report_id
+                }
 
         finally:
             # Clean up the temporary directory and file
             shutil.rmtree(temp_dir)
 
-
         def process_multiple_reports(self, report_files):
             """Process multiple medical reports (up to 3)"""
             if not report_files or len(report_files) == 0:
@@ -708,7 +707,6 @@ class MedicalReportAnalyzer:
                 "reports": report_results
             }
 
-
         def answer_question(self, question, report_id=None):
             """Answer a question based on the uploaded report and knowledge base"""
             # Use the specified report_id or the most recent one
@@ -792,9 +790,9 @@ class MedicalReportAnalyzer:
                     # Create prompt for Gemini
                     gemini_prompt = f"""
                                 Question about medical report: {question}
-        
+
                                 Patient data available: {report_text[:2000]}... (truncated)
-        
+
                                 Please analyze this medical report data and answer the question. 
                                 Your answer should:
                                 1. Be strictly under 350 words
@@ -817,589 +815,586 @@ class MedicalReportAnalyzer:
                 except Exception as gemini_error:
                     return f"{error_msg} Gemini fallback also failed: {str(gemini_error)}. Please try a different question or report."
 
+    def generate_single_report_analysis(self, report_id=None):
+        """Generate a comprehensive analysis of a single report"""
+        # Use the specified report_id or the most recent one
+        target_report_id = report_id or self.current_report_id
 
-        def generate_single_report_analysis(self, report_id=None):
-            """Generate a comprehensive analysis of a single report"""
-            # Use the specified report_id or the most recent one
-            target_report_id = report_id or self.current_report_id
-
-            if not target_report_id or target_report_id not in self.reports:
-                return {
-                    "status": "error",
-                    "message": "No report has been processed or the specified report ID is invalid."
-                }
+        if not target_report_id or target_report_id not in self.reports:
+            return {
+                "status": "error",
+                "message": "No report has been processed or the specified report ID is invalid."
+            }
 
-            report = self.reports[target_report_id]
+        report = self.reports[target_report_id]
 
-            try:
-                # Group parameters by category
-                categories = {
-                    "blood_count": ["hemoglobin", "hb", "rbc", "wbc", "platelets"],
-                    "glucose": ["glucose", "hba1c"],
-                    "lipids": ["cholesterol", "ldl", "hdl", "triglycerides"],
-                    "liver_function": ["ast", "alt", "bilirubin", "alp", "ggt"],
-                    "kidney_function": ["creatinine", "urea", "uric_acid"],
-                    "thyroid": ["tsh", "t3", "t4"],
-                    "vitamins": ["vitamin_d", "vitamin_b12"],
-                    "electrolytes": ["sodium", "potassium", "calcium"]
-                }
+        try:
+            # Group parameters by category
+            categories = {
+                "blood_count": ["hemoglobin", "hb", "rbc", "wbc", "platelets"],
+                "glucose": ["glucose", "hba1c"],
+                "lipids": ["cholesterol", "ldl", "hdl", "triglycerides"],
+                "liver_function": ["ast", "alt", "bilirubin", "alp", "ggt"],
+                "kidney_function": ["creatinine", "urea", "uric_acid"],
+                "thyroid": ["tsh", "t3", "t4"],
+                "vitamins": ["vitamin_d", "vitamin_b12"],
+                "electrolytes": ["sodium", "potassium", "calcium"]
+            }
 
-                # Organize parameters by category
-                categorized_params = {}
-                uncategorized_params = []
-
-                for param_name, param_data in report.parameters.items():
-                    categorized = False
-                    for category, params in categories.items():
-                        if param_name in params:
-                            if category not in categorized_params:
-                                categorized_params[category] = []
-                            categorized_params[category].append({
-                                "name": param_name,
-                                **param_data
-                            })
-                            categorized = True
-                            break
-
-                    if not categorized:
-                        uncategorized_params.append({
+            # Organize parameters by category
+            categorized_params = {}
+            uncategorized_params = []
+
+            for param_name, param_data in report.parameters.items():
+                categorized = False
+                for category, params in categories.items():
+                    if param_name in params:
+                        if category not in categorized_params:
+                            categorized_params[category] = []
+                        categorized_params[category].append({
                             "name": param_name,
                             **param_data
                         })
+                        categorized = True
+                        break
+
+                if not categorized:
+                    uncategorized_params.append({
+                        "name": param_name,
+                        **param_data
+                    })
+
+            # Generate analysis for abnormal parameters
+            abnormal_analysis = []
+            for abnormal in report.abnormal_parameters:
+                param_name = abnormal["name"]
+                status = abnormal["status"]
+                value = abnormal["value"]
+                min_val = abnormal["min"]
+                max_val = abnormal["max"]
+
+                # Get parameter details
+                param_data = report.parameters.get(param_name, {})
+                unit = param_data.get("unit", "")
+
+                if status == "low":
+                    analysis = f"{param_name.upper()} is LOW at {value} {unit} (below reference range of {min_val}-{max_val} {unit})"
+                else:
+                    analysis = f"{param_name.upper()} is HIGH at {value} {unit} (above reference range of {min_val}-{max_val} {unit})"
+
+                abnormal_analysis.append(analysis)
+
+            # Generate health suggestions using LLM
+            suggestions_prompt = f"""
+                        As a medical assistant, provide simple health suggestions for a patient with the following abnormal results:
+
+                        {' '.join(abnormal_analysis)}
+
+                        Please provide:
+                        1. A brief explanation of what each abnormal result might indicate (in simple terms)
+                        2. General lifestyle suggestions that might help improve these values
+                        3. When the patient should consider consulting a doctor
+
+                        Keep your response under 400 words and use simple, non-technical language. DO NOT include disclaimers about not being a doctor or medical advice, just provide the information directly.
+                        """
+
+            # Use LLM to generate suggestions
+            health_suggestions = self.answer_question(suggestions_prompt, report_id)
+
+            # Create visualization data
+            visualization_data = self.create_single_report_visualizations(report)
+
+            # Assemble the complete analysis
+            analysis = {
+                "status": "success",
+                "report_id": target_report_id,
+                "report_date": report.date.isoformat() if isinstance(report.date, datetime) else report.date,
+                "gender": report.gender,
+                "parameters_count": len(report.parameters),
+                "abnormal_count": len(report.abnormal_parameters),
+                "abnormal_parameters": report.abnormal_parameters,
+                "categorized_parameters": categorized_params,
+                "uncategorized_parameters": uncategorized_params,
+                "health_suggestions": health_suggestions,
+                "visualizations": visualization_data
+            }
+
+            return analysis
+
+        except Exception as e:
+            print(f"Error generating report analysis: {str(e)}")
+            return {
+                "status": "error",
+                "message": f"Error generating analysis: {str(e)}"
+            }
+
+    def create_single_report_visualizations(self, report):
+        """Create visualizations for a single report"""
+        try:
+            # 1. Parameters Status Chart (normal vs abnormal)
+            normal_count = len(report.parameters) - len(report.abnormal_parameters)
+            abnormal_count = len(report.abnormal_parameters)
+
+            status_chart = {
+                "type": "pie",
+                "data": {
+                    "labels": ["Normal", "Abnormal"],
+                    "values": [normal_count, abnormal_count]
+                },
+                "title": "Parameter Status Distribution"
+            }
+
+            # 2. Abnormal Parameters Chart
+            if abnormal_count > 0:
+                abnormal_names = []
+                abnormal_percentages = []
 
-                # Generate analysis for abnormal parameters
-                abnormal_analysis = []
                 for abnormal in report.abnormal_parameters:
                     param_name = abnormal["name"]
-                    status = abnormal["status"]
                     value = abnormal["value"]
                     min_val = abnormal["min"]
                     max_val = abnormal["max"]
 
-                    # Get parameter details
-                    param_data = report.parameters.get(param_name, {})
-                    unit = param_data.get("unit", "")
-
-                    if status == "low":
-                        analysis = f"{param_name.upper()} is LOW at {value} {unit} (below reference range of {min_val}-{max_val} {unit})"
+                    if value < min_val:
+                        # Calculate how much below min (as percentage)
+                        deviation = (min_val - value) / min_val * 100
+                        abnormal_names.append(f"{param_name} (Low)")
                     else:
-                        analysis = f"{param_name.upper()} is HIGH at {value} {unit} (above reference range of {min_val}-{max_val} {unit})"
-
-                    abnormal_analysis.append(analysis)
-
-                # Generate health suggestions using LLM
-                suggestions_prompt = f"""
-                            As a medical assistant, provide simple health suggestions for a patient with the following abnormal results:
-        
-                            {' '.join(abnormal_analysis)}
-        
-                            Please provide:
-                            1. A brief explanation of what each abnormal result might indicate (in simple terms)
-                            2. General lifestyle suggestions that might help improve these values
-                            3. When the patient should consider consulting a doctor
-        
-                            Keep your response under 400 words and use simple, non-technical language. DO NOT include disclaimers about not being a doctor or medical advice, just provide the information directly.
-                            """
-
-                # Use LLM to generate suggestions
-                health_suggestions = self.answer_question(suggestions_prompt, report_id)
-
-                # Create visualization data
-                visualization_data = self.create_single_report_visualizations(report)
-
-                # Assemble the complete analysis
-                analysis = {
-                    "status": "success",
-                    "report_id": target_report_id,
-                    "report_date": report.date.isoformat() if isinstance(report.date, datetime) else report.date,
-                    "gender": report.gender,
-                    "parameters_count": len(report.parameters),
-                    "abnormal_count": len(report.abnormal_parameters),
-                    "abnormal_parameters": report.abnormal_parameters,
-                    "categorized_parameters": categorized_params,
-                    "uncategorized_parameters": uncategorized_params,
-                    "health_suggestions": health_suggestions,
-                    "visualizations": visualization_data
-                }
-
-                return analysis
-
-            except Exception as e:
-                print(f"Error generating report analysis: {str(e)}")
-                return {
-                    "status": "error",
-                    "message": f"Error generating analysis: {str(e)}"
-                }
+                        # Calculate how much above max (as percentage)
+                        deviation = (value - max_val) / max_val * 100
+                        abnormal_names.append(f"{param_name} (High)")
 
+                    # Cap at 100% for very extreme values
+                    deviation = min(deviation, 100)
+                    abnormal_percentages.append(deviation)
 
-        def create_single_report_visualizations(self, report):
-            """Create visualizations for a single report"""
-            try:
-                # 1. Parameters Status Chart (normal vs abnormal)
-                normal_count = len(report.parameters) - len(report.abnormal_parameters)
-                abnormal_count = len(report.abnormal_parameters)
-
-                status_chart = {
-                    "type": "pie",
+                abnormal_chart = {
+                    "type": "bar",
                     "data": {
-                        "labels": ["Normal", "Abnormal"],
-                        "values": [normal_count, abnormal_count]
+                        "labels": abnormal_names,
+                        "values": abnormal_percentages
                     },
-                    "title": "Parameter Status Distribution"
+                    "title": "Abnormal Parameters (% Deviation from Reference)"
                 }
+            else:
+                abnormal_chart = None
+
+            # 3. Category Distribution Chart
+            categories = {
+                "blood_count": ["hemoglobin", "hb", "rbc", "wbc", "platelets"],
+                "glucose": ["glucose", "hba1c"],
+                "lipids": ["cholesterol", "ldl", "hdl", "triglycerides"],
+                "liver_function": ["ast", "alt", "bilirubin", "alp", "ggt"],
+                "kidney_function": ["creatinine", "urea", "uric_acid"],
+                "thyroid": ["tsh", "t3", "t4"],
+                "vitamins": ["vitamin_d", "vitamin_b12"],
+                "electrolytes": ["sodium", "potassium", "calcium"]
+            }
 
-                # 2. Abnormal Parameters Chart
-                if abnormal_count > 0:
-                    abnormal_names = []
-                    abnormal_percentages = []
-
-                    for abnormal in report.abnormal_parameters:
-                        param_name = abnormal["name"]
-                        value = abnormal["value"]
-                        min_val = abnormal["min"]
-                        max_val = abnormal["max"]
-
-                        if value < min_val:
-                            # Calculate how much below min (as percentage)
-                            deviation = (min_val - value) / min_val * 100
-                            abnormal_names.append(f"{param_name} (Low)")
-                        else:
-                            # Calculate how much above max (as percentage)
-                            deviation = (value - max_val) / max_val * 100
-                            abnormal_names.append(f"{param_name} (High)")
-
-                        # Cap at 100% for very extreme values
-                        deviation = min(deviation, 100)
-                        abnormal_percentages.append(deviation)
-
-                    abnormal_chart = {
-                        "type": "bar",
-                        "data": {
-                            "labels": abnormal_names,
-                            "values": abnormal_percentages
-                        },
-                        "title": "Abnormal Parameters (% Deviation from Reference)"
-                    }
-                else:
-                    abnormal_chart = None
-
-                # 3. Category Distribution Chart
-                categories = {
-                    "blood_count": ["hemoglobin", "hb", "rbc", "wbc", "platelets"],
-                    "glucose": ["glucose", "hba1c"],
-                    "lipids": ["cholesterol", "ldl", "hdl", "triglycerides"],
-                    "liver_function": ["ast", "alt", "bilirubin", "alp", "ggt"],
-                    "kidney_function": ["creatinine", "urea", "uric_acid"],
-                    "thyroid": ["tsh", "t3", "t4"],
-                    "vitamins": ["vitamin_d", "vitamin_b12"],
-                    "electrolytes": ["sodium", "potassium", "calcium"]
-                }
+            category_counts = {"Other": 0}
+            for param_name in report.parameters:
+                categorized = False
+                for category, params in categories.items():
+                    if param_name in params:
+                        if category not in category_counts:
+                            category_counts[category] = 0
+                        category_counts[category] += 1
+                        categorized = True
+                        break
+
+                if not categorized:
+                    category_counts["Other"] += 1
+
+            category_chart = {
+                "type": "pie",
+                "data": {
+                    "labels": list(category_counts.keys()),
+                    "values": list(category_counts.values())
+                },
+                "title": "Parameter Categories"
+            }
 
-                category_counts = {"Other": 0}
-                for param_name in report.parameters:
-                    categorized = False
-                    for category, params in categories.items():
-                        if param_name in params:
-                            if category not in category_counts:
-                                category_counts[category] = 0
-                            category_counts[category] += 1
-                            categorized = True
-                            break
-
-                    if not categorized:
-                        category_counts["Other"] += 1
-
-                category_chart = {
-                    "type": "pie",
-                    "data": {
-                        "labels": list(category_counts.keys()),
-                        "values": list(category_counts.values())
-                    },
-                    "title": "Parameter Categories"
-                }
+            # Return all visualization data
+            return {
+                "status_chart": status_chart,
+                "abnormal_chart": abnormal_chart,
+                "category_chart": category_chart
+            }
 
-                # Return all visualization data
-                return {
-                    "status_chart": status_chart,
-                    "abnormal_chart": abnormal_chart,
-                    "category_chart": category_chart
-                }
+        except Exception as e:
+            print(f"Error creating visualizations: {str(e)}")
+            return {
+                "status": "error",
+                "message": f"Error creating visualizations: {str(e)}"
+            }
 
-            except Exception as e:
-                print(f"Error creating visualizations: {str(e)}")
+    def compare_reports(self, report_ids):
+        """Compare multiple reports (2-3) and generate analysis with visualizations"""
+        if not report_ids or len(report_ids) < 2:
+            return {
+                "status": "error",
+                "message": "At least two report IDs are required for comparison."
+            }
+
+        if len(report_ids) > 3:
+            return {
+                "status": "error",
+                "message": "Maximum 3 reports can be compared at once."
+            }
+
+        # Verify all report IDs exist
+        for report_id in report_ids:
+            if report_id not in self.reports:
                 return {
                     "status": "error",
-                    "message": f"Error creating visualizations: {str(e)}"
+                    "message": f"Report ID {report_id} not found."
                 }
 
+        try:
+            # Get report objects
+            report_objects = [self.reports[report_id] for report_id in report_ids]
+
+            # Sort reports by date (oldest to newest)
+            report_objects.sort(key=lambda r: r.date if isinstance(r.date, datetime) else datetime.now())
+
+            # Extract common parameters across all reports
+            common_parameters = set(report_objects[0].parameters.keys())
+            for report in report_objects[1:]:
+                common_parameters = common_parameters.intersection(set(report.parameters.keys()))
 
-        def compare_reports(self, report_ids):
-            """Compare multiple reports (2-3) and generate analysis with visualizations"""
-            if not report_ids or len(report_ids) < 2:
+            # If no common parameters, return error
+            if not common_parameters:
                 return {
                     "status": "error",
-                    "message": "At least two report IDs are required for comparison."
+                    "message": "No common parameters found across the reports for comparison."
                 }
 
-            if len(report_ids) > 3:
-                return {
-                    "status": "error",
-                    "message": "Maximum 3 reports can be compared at once."
+            # Create parameter trends
+            parameter_trends = {}
+            for param in common_parameters:
+                values = []
+                dates = []
+                statuses = []
+
+                for report in report_objects:
+                    if param in report.parameters:
+                        param_data = report.parameters[param]
+                        values.append(param_data["value"])
+                        dates.append(
+                            report.date.strftime('%Y-%m-%d') if isinstance(report.date, datetime) else str(
+                                report.date))
+                        statuses.append(param_data.get("status", "unknown"))
+
+                parameter_trends[param] = {
+                    "name": param,
+                    "values": values,
+                    "dates": dates,
+                    "statuses": statuses
                 }
 
-            # Verify all report IDs exist
-            for report_id in report_ids:
-                if report_id not in self.reports:
-                    return {
-                        "status": "error",
-                        "message": f"Report ID {report_id} not found."
-                    }
+            # Generate chart data for trends
+            trend_charts = []
+            for param, trend_data in parameter_trends.items():
+                # Get reference ranges if available
+                ref_min = None
+                ref_max = None
+
+                if param in STANDARD_RANGES:
+                    if "min" in STANDARD_RANGES[param]:
+                        ref_min = STANDARD_RANGES[param]["min"]
+                    if "max" in STANDARD_RANGES[param]:
+                        ref_max = STANDARD_RANGES[param]["max"]
+
+                # Calculate percent change between first and last value
+                if len(trend_data["values"]) >= 2:
+                    first_val = trend_data["values"][0]
+                    last_val = trend_data["values"][-1]
+                    if first_val != 0:  # Avoid division by zero
+                        percent_change = ((last_val - first_val) / first_val) * 100
+                    else:
+                        percent_change = 0
 
-            try:
-                # Get report objects
-                report_objects = [self.reports[report_id] for report_id in report_ids]
+                    # Determine if the change is good or bad
+                    if "status" in trend_data:
+                        first_status = trend_data["statuses"][0]
+                        last_status = trend_data["statuses"][-1]
+
+                        # Improved if: was abnormal and now normal OR was high and decreased OR was low and increased
+                        if (first_status != "normal" and last_status == "normal") or \
+                                (first_status == "high" and last_val < first_val) or \
+                                (first_status == "low" and last_val > first_val):
+                            trend = "improved"
+                        # Worsened if: was normal and now abnormal OR was high and increased OR was low and decreased
+                        elif (first_status == "normal" and last_status != "normal") or \
+                                (first_status == "high" and last_val > first_val) or \
+                                (first_status == "low" and last_val < first_val):
+                            trend = "worsened"
+                        else:
+                            trend = "unchanged"
+                    else:
+                        trend = "unknown"
+                else:
+                    percent_change = 0
+                    trend = "unknown"
 
-                # Sort reports by date (oldest to newest)
-                report_objects.sort(key=lambda r: r.date if isinstance(r.date, datetime) else datetime.now())
+                # Create chart data
+                chart = {
+                    "type": "line",
+                    "data": {
+                        "labels": trend_data["dates"],
+                        "values": trend_data["values"]
+                    },
+                    "metadata": {
+                        "parameter": param,
+                        "percent_change": round(percent_change, 2),
+                        "trend": trend,
+                        "reference_min": ref_min,
+                        "reference_max": ref_max
+                    },
+                    "title": f"{param.upper()} Trend"
+                }
 
-                # Extract common parameters across all reports
-                common_parameters = set(report_objects[0].parameters.keys())
-                for report in report_objects[1:]:
-                    common_parameters = common_parameters.intersection(set(report.parameters.keys()))
+                trend_charts.append(chart)
+
+            # Group parameters by category for card-based UI
+            categories = {
+                "blood_count": ["hemoglobin", "hb", "rbc", "wbc", "platelets"],
+                "glucose": ["glucose", "hba1c"],
+                "lipids": ["cholesterol", "ldl", "hdl", "triglycerides"],
+                "liver_function": ["ast", "alt", "bilirubin", "alp", "ggt"],
+                "kidney_function": ["creatinine", "urea", "uric_acid"],
+                "thyroid": ["tsh", "t3", "t4"],
+                "vitamins": ["vitamin_d", "vitamin_b12"],
+                "electrolytes": ["sodium", "potassium", "calcium"]
+            }
 
-                # If no common parameters, return error
-                if not common_parameters:
-                    return {
-                        "status": "error",
-                        "message": "No common parameters found across the reports for comparison."
-                    }
+            # Organize charts by category
+            categorized_charts = {}
+            uncategorized_charts = []
+
+            for chart in trend_charts:
+                param_name = chart["metadata"]["parameter"]
+                categorized = False
+
+                for category, params in categories.items():
+                    if param_name in params:
+                        if category not in categorized_charts:
+                            categorized_charts[category] = []
+                        categorized_charts[category].append(chart)
+                        categorized = True
+                        break
+
+                if not categorized:
+                    uncategorized_charts.append(chart)
+
+            # Create a summary chart showing overall health trends
+            improved_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "improved")
+            worsened_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "worsened")
+            unchanged_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "unchanged")
+            unknown_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "unknown")
+
+            summary_chart = {
+                "type": "pie",
+                "data": {
+                    "labels": ["Improved", "Worsened", "Unchanged", "Unknown"],
+                    "values": [improved_count, worsened_count, unchanged_count, unknown_count]
+                },
+                "title": "Overall Health Trends"
+            }
 
-                # Create parameter trends
-                parameter_trends = {}
-                for param in common_parameters:
-                    values = []
-                    dates = []
-                    statuses = []
-
-                    for report in report_objects:
-                        if param in report.parameters:
-                            param_data = report.parameters[param]
-                            values.append(param_data["value"])
-                            dates.append(
-                                report.date.strftime('%Y-%m-%d') if isinstance(report.date, datetime) else str(report.date))
-                            statuses.append(param_data.get("status", "unknown"))
-
-                    parameter_trends[param] = {
-                        "name": param,
-                        "values": values,
-                        "dates": dates,
-                        "statuses": statuses
-                    }
+            # Generate insights using the LLM
+            insights_prompt = f"""
+                        As a medical assistant, I need to generate insights about how a patient's health has changed between medical reports.
 
-                # Generate chart data for trends
-                trend_charts = []
-                for param, trend_data in parameter_trends.items():
-                    # Get reference ranges if available
-                    ref_min = None
-                    ref_max = None
-
-                    if param in STANDARD_RANGES:
-                        if "min" in STANDARD_RANGES[param]:
-                            ref_min = STANDARD_RANGES[param]["min"]
-                        if "max" in STANDARD_RANGES[param]:
-                            ref_max = STANDARD_RANGES[param]["max"]
-
-                    # Calculate percent change between first and last value
-                    if len(trend_data["values"]) >= 2:
-                        first_val = trend_data["values"][0]
-                        last_val = trend_data["values"][-1]
-                        if first_val != 0:  # Avoid division by zero
-                            percent_change = ((last_val - first_val) / first_val) * 100
-                        else:
-                            percent_change = 0
-
-                        # Determine if the change is good or bad
-                        if "status" in trend_data:
-                            first_status = trend_data["statuses"][0]
-                            last_status = trend_data["statuses"][-1]
-
-                            # Improved if: was abnormal and now normal OR was high and decreased OR was low and increased
-                            if (first_status != "normal" and last_status == "normal") or \
-                                    (first_status == "high" and last_val < first_val) or \
-                                    (first_status == "low" and last_val > first_val):
-                                trend = "improved"
-                            # Worsened if: was normal and now abnormal OR was high and increased OR was low and decreased
-                            elif (first_status == "normal" and last_status != "normal") or \
-                                    (first_status == "high" and last_val > first_val) or \
-                                    (first_status == "low" and last_val < first_val):
-                                trend = "worsened"
-                            else:
-                                trend = "unchanged"
-                        else:
-                            trend = "unknown"
-                    else:
-                        percent_change = 0
-                        trend = "unknown"
+                        Here are the key changes:
+                        """
 
-                    # Create chart data
-                    chart = {
-                        "type": "line",
-                        "data": {
-                            "labels": trend_data["dates"],
-                            "values": trend_data["values"]
-                        },
-                        "metadata": {
-                            "parameter": param,
-                            "percent_change": round(percent_change, 2),
-                            "trend": trend,
-                            "reference_min": ref_min,
-                            "reference_max": ref_max
-                        },
-                        "title": f"{param.upper()} Trend"
-                    }
+            # Add significant changes to the prompt
+            for chart in trend_charts:
+                param = chart["metadata"]["parameter"]
+                change = chart["metadata"]["percent_change"]
+                trend = chart["metadata"]["trend"]
 
-                    trend_charts.append(chart)
-
-                # Group parameters by category for card-based UI
-                categories = {
-                    "blood_count": ["hemoglobin", "hb", "rbc", "wbc", "platelets"],
-                    "glucose": ["glucose", "hba1c"],
-                    "lipids": ["cholesterol", "ldl", "hdl", "triglycerides"],
-                    "liver_function": ["ast", "alt", "bilirubin", "alp", "ggt"],
-                    "kidney_function": ["creatinine", "urea", "uric_acid"],
-                    "thyroid": ["tsh", "t3", "t4"],
-                    "vitamins": ["vitamin_d", "vitamin_b12"],
-                    "electrolytes": ["sodium", "potassium", "calcium"]
-                }
+                if abs(change) > 5:  # Only include significant changes (>5%)
+                    insights_prompt += f"\n- {param}: {change:+.1f}% change ({trend})"
 
-                # Organize charts by category
-                categorized_charts = {}
-                uncategorized_charts = []
-
-                for chart in trend_charts:
-                    param_name = chart["metadata"]["parameter"]
-                    categorized = False
-
-                    for category, params in categories.items():
-                        if param_name in params:
-                            if category not in categorized_charts:
-                                categorized_charts[category] = []
-                            categorized_charts[category].append(chart)
-                            categorized = True
-                            break
-
-                    if not categorized:
-                        uncategorized_charts.append(chart)
-
-                # Create a summary chart showing overall health trends
-                improved_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "improved")
-                worsened_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "worsened")
-                unchanged_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "unchanged")
-                unknown_count = sum(1 for chart in trend_charts if chart["metadata"]["trend"] == "unknown")
-
-                summary_chart = {
-                    "type": "pie",
-                    "data": {
-                        "labels": ["Improved", "Worsened", "Unchanged", "Unknown"],
-                        "values": [improved_count, worsened_count, unchanged_count, unknown_count]
-                    },
-                    "title": "Overall Health Trends"
-                }
+            insights_prompt += """
 
-                # Generate insights using the LLM
-                insights_prompt = f"""
-                            As a medical assistant, I need to generate insights about how a patient's health has changed between medical reports.
-        
-                            Here are the key changes:
-                            """
-
-                # Add significant changes to the prompt
-                for chart in trend_charts:
-                    param = chart["metadata"]["parameter"]
-                    change = chart["metadata"]["percent_change"]
-                    trend = chart["metadata"]["trend"]
-
-                    if abs(change) > 5:  # Only include significant changes (>5%)
-                        insights_prompt += f"\n- {param}: {change:+.1f}% change ({trend})"
-
-                insights_prompt += """
-        
-                            Based on these changes, please provide:
-                            1. A brief overview of the overall health trend (improved, worsened, or mixed)
-                            2. The most significant positive changes and what they might indicate
-                            3. The most significant concerns and what they might indicate
-                            4. 3-5 specific recommendations based on these trends
-        
-                            Keep your response under 400 words and use simple, non-technical language that a patient can understand. 
-                            DO NOT include disclaimers about not being a doctor or medical advice, just provide the information directly.
-                            """
-
-                # Use LLM to generate insights
-                health_insights = self.answer_question(insights_prompt)
-
-                # Assemble the complete comparison
-                comparison = {
-                    "status": "success",
-                    "report_count": len(report_ids),
-                    "report_dates": [r.date.strftime('%Y-%m-%d') if isinstance(r.date, datetime) else str(r.date) for r in
-                                     report_objects],
-                    "common_parameters_count": len(common_parameters),
-                    "parameter_trends": parameter_trends,
-                    "categorized_charts": categorized_charts,
-                    "uncategorized_charts": uncategorized_charts,
-                    "summary_chart": summary_chart,
-                    "health_insights": health_insights,
-                    "statistics": {
-                        "improved": improved_count,
-                        "worsened": worsened_count,
-                        "unchanged": unchanged_count,
-                        "unknown": unknown_count
-                    }
-                }
+                        Based on these changes, please provide:
+                        1. A brief overview of the overall health trend (improved, worsened, or mixed)
+                        2. The most significant positive changes and what they might indicate
+                        3. The most significant concerns and what they might indicate
+                        4. 3-5 specific recommendations based on these trends
 
-                return comparison
+                        Keep your response under 400 words and use simple, non-technical language that a patient can understand. 
+                        DO NOT include disclaimers about not being a doctor or medical advice, just provide the information directly.
+                        """
 
-            except Exception as e:
-                print(f"Error comparing reports: {str(e)}")
-                return {
-                    "status": "error",
-                    "message": f"Error comparing reports: {str(e)}"
+            # Use LLM to generate insights
+            health_insights = self.answer_question(insights_prompt)
+
+            # Assemble the complete comparison
+            comparison = {
+                "status": "success",
+                "report_count": len(report_ids),
+                "report_dates": [r.date.strftime('%Y-%m-%d') if isinstance(r.date, datetime) else str(r.date) for r
+                                 in
+                                 report_objects],
+                "common_parameters_count": len(common_parameters),
+                "parameter_trends": parameter_trends,
+                "categorized_charts": categorized_charts,
+                "uncategorized_charts": uncategorized_charts,
+                "summary_chart": summary_chart,
+                "health_insights": health_insights,
+                "statistics": {
+                    "improved": improved_count,
+                    "worsened": worsened_count,
+                    "unchanged": unchanged_count,
+                    "unknown": unknown_count
                 }
+            }
 
+            return comparison
 
-        def generate_visualization_image(self, chart_data, width=600, height=400):
-            """Generate visualization image based on chart data and return as base64"""
-            try:
-                plt.figure(figsize=(width / 100, height / 100), dpi=100)
+        except Exception as e:
+            print(f"Error comparing reports: {str(e)}")
+            return {
+                "status": "error",
+                "message": f"Error comparing reports: {str(e)}"
+            }
 
-                # Handle different chart types
-                chart_type = chart_data.get("type", "bar")
-                data = chart_data.get("data", {})
-                title = chart_data.get("title", "Chart")
+    def generate_visualization_image(self, chart_data, width=600, height=400):
+        """Generate visualization image based on chart data and return as base64"""
+        try:
+            plt.figure(figsize=(width / 100, height / 100), dpi=100)
 
-                labels = data.get("labels", [])
-                values = data.get("values", [])
+            # Handle different chart types
+            chart_type = chart_data.get("type", "bar")
+            data = chart_data.get("data", {})
+            title = chart_data.get("title", "Chart")
 
-                if chart_type == "bar":
-                    plt.bar(labels, values)
-                    plt.xticks(rotation=45, ha="right")
-                    plt.tight_layout()
+            labels = data.get("labels", [])
+            values = data.get("values", [])
 
-                elif chart_type == "line":
-                    plt.plot(labels, values, marker='o')
-                    plt.xticks(rotation=45, ha="right")
-                    plt.tight_layout()
+            if chart_type == "bar":
+                plt.bar(labels, values)
+                plt.xticks(rotation=45, ha="right")
+                plt.tight_layout()
 
-                    # Add reference range if available
-                    metadata = chart_data.get("metadata", {})
-                    ref_min = metadata.get("reference_min")
-                    ref_max = metadata.get("reference_max")
+            elif chart_type == "line":
+                plt.plot(labels, values, marker='o')
+                plt.xticks(rotation=45, ha="right")
+                plt.tight_layout()
 
-                    if ref_min is not None:
-                        plt.axhline(y=ref_min, color='r', linestyle='--', alpha=0.5)
-                    if ref_max is not None:
-                        plt.axhline(y=ref_max, color='r', linestyle='--', alpha=0.5)
+                # Add reference range if available
+                metadata = chart_data.get("metadata", {})
+                ref_min = metadata.get("reference_min")
+                ref_max = metadata.get("reference_max")
 
-                elif chart_type == "pie":
-                    plt.pie(values, labels=labels, autopct='%1.1f%%', startangle=90)
-                    plt.axis('equal')
+                if ref_min is not None:
+                    plt.axhline(y=ref_min, color='r', linestyle='--', alpha=0.5)
+                if ref_max is not None:
+                    plt.axhline(y=ref_max, color='r', linestyle='--', alpha=0.5)
 
-                else:
-                    raise ValueError(f"Unsupported chart type: {chart_type}")
+            elif chart_type == "pie":
+                plt.pie(values, labels=labels, autopct='%1.1f%%', startangle=90)
+                plt.axis('equal')
 
-                plt.title(title)
+            else:
+                raise ValueError(f"Unsupported chart type: {chart_type}")
 
-                # Save the plot to a binary buffer
-                buf = io.BytesIO()
-                plt.savefig(buf, format='png')
-                buf.seek(0)
+            plt.title(title)
 
-                # Convert to base64
-                image_base64 = base64.b64encode(buf.read()).decode('utf-8')
-                plt.close()
+            # Save the plot to a binary buffer
+            buf = io.BytesIO()
+            plt.savefig(buf, format='png')
+            buf.seek(0)
 
-                return image_base64
+            # Convert to base64
+            image_base64 = base64.b64encode(buf.read()).decode('utf-8')
+            plt.close()
 
-            except Exception as e:
-                print(f"Error generating chart: {str(e)}")
-                return None
+            return image_base64
 
+        except Exception as e:
+            print(f"Error generating chart: {str(e)}")
+            return None
 
-        def generate_interactive_chart(self, chart_data):
-            """Generate an interactive Plotly chart based on chart_data"""
-            try:
-                chart_type = chart_data.get("type", "bar")
-                data = chart_data.get("data", {})
-                title = chart_data.get("title", "Chart")
-
-                labels = data.get("labels", [])
-                values = data.get("values", [])
-
-                if chart_type == "bar":
-                    fig = px.bar(x=labels, y=values, title=title)
-                    fig.update_layout(xaxis_title="", yaxis_title="Value")
-
-                elif chart_type == "line":
-                    fig = px.line(x=labels, y=values, markers=True, title=title)
-                    fig.update_layout(xaxis_title="Date", yaxis_title="Value")
-
-                    # Add reference range if available
-                    metadata = chart_data.get("metadata", {})
-                    ref_min = metadata.get("reference_min")
-                    ref_max = metadata.get("reference_max")
-
-                    if ref_min is not None:
-                        fig.add_shape(type="line", line_color="red", line_dash="dash",
-                                      x0=0, y0=ref_min, x1=1, y1=ref_min,
-                                      xref="paper", yref="y")
-                    if ref_max is not None:
-                        fig.add_shape(type="line", line_color="red", line_dash="dash",
-                                      x0=0, y0=ref_max, x1=1, y1=ref_max,
-                                      xref="paper", yref="y")
-
-                elif chart_type == "pie":
-                    fig = px.pie(values=values, names=labels, title=title)
-
-                elif chart_type == "gauge":
-                    # Extract gauge-specific properties
-                    value = values[0] if values else 0
-                    min_val = data.get("min", 0)
-                    max_val = data.get("max", 100)
-
-                    fig = go.Figure(go.Indicator(
-                        mode="gauge+number",
-                        value=value,
-                        title={"text": title},
-                        gauge={
-                            "axis": {"range": [min_val, max_val]},
-                            "bar": {"color": "darkblue"},
-                            "steps": [
-                                {"range": [min_val, min_val + (max_val - min_val) / 3], "color": "red"},
-                                {"range": [min_val + (max_val - min_val) / 3, min_val + 2 * (max_val - min_val) / 3],
-                                 "color": "yellow"},
-                                {"range": [min_val + 2 * (max_val - min_val) / 3, max_val], "color": "green"}
-                            ]
-                        }
-                    ))
+    def generate_interactive_chart(self, chart_data):
+        """Generate an interactive Plotly chart based on chart_data"""
+        try:
+            chart_type = chart_data.get("type", "bar")
+            data = chart_data.get("data", {})
+            title = chart_data.get("title", "Chart")
+
+            labels = data.get("labels", [])
+            values = data.get("values", [])
+
+            if chart_type == "bar":
+                fig = px.bar(x=labels, y=values, title=title)
+                fig.update_layout(xaxis_title="", yaxis_title="Value")
+
+            elif chart_type == "line":
+                fig = px.line(x=labels, y=values, markers=True, title=title)
+                fig.update_layout(xaxis_title="Date", yaxis_title="Value")
+
+                # Add reference range if available
+                metadata = chart_data.get("metadata", {})
+                ref_min = metadata.get("reference_min")
+                ref_max = metadata.get("reference_max")
+
+                if ref_min is not None:
+                    fig.add_shape(type="line", line_color="red", line_dash="dash",
+                                  x0=0, y0=ref_min, x1=1, y1=ref_min,
+                                  xref="paper", yref="y")
+                if ref_max is not None:
+                    fig.add_shape(type="line", line_color="red", line_dash="dash",
+                                  x0=0, y0=ref_max, x1=1, y1=ref_max,
+                                  xref="paper", yref="y")
+
+            elif chart_type == "pie":
+                fig = px.pie(values=values, names=labels, title=title)
+
+            elif chart_type == "gauge":
+                # Extract gauge-specific properties
+                value = values[0] if values else 0
+                min_val = data.get("min", 0)
+                max_val = data.get("max", 100)
+
+                fig = go.Figure(go.Indicator(
+                    mode="gauge+number",
+                    value=value,
+                    title={"text": title},
+                    gauge={
+                        "axis": {"range": [min_val, max_val]},
+                        "bar": {"color": "darkblue"},
+                        "steps": [
+                            {"range": [min_val, min_val + (max_val - min_val) / 3], "color": "red"},
+                            {"range": [min_val + (max_val - min_val) / 3, min_val + 2 * (max_val - min_val) / 3],
+                             "color": "yellow"},
+                            {"range": [min_val + 2 * (max_val - min_val) / 3, max_val], "color": "green"}
+                        ]
+                    }
+                ))
 
-                else:
-                    raise ValueError(f"Unsupported chart type: {chart_type}")
-
-                # Set consistent layout properties
-                fig.update_layout(
-                    title_x=0.5,
-                    margin=dict(l=50, r=50, b=50, t=80),
-                    height=400,
-                    width=600
-                )
+            else:
+                raise ValueError(f"Unsupported chart type: {chart_type}")
+
+            # Set consistent layout properties
+            fig.update_layout(
+                title_x=0.5,
+                margin=dict(l=50, r=50, b=50, t=80),
+                height=400,
+                width=600
+            )
 
-                # Convert to JSON for use in HTML/JavaScript
-                chart_json = fig.to_json()
-                return chart_json
+            # Convert to JSON for use in HTML/JavaScript
+            chart_json = fig.to_json()
+            return chart_json
 
-            except Exception as e:
-                print(f"Error generating interactive chart: {str(e)}")
-                return None
+        except Exception as e:
+            print(f"Error generating interactive chart: {str(e)}")
+            return None
 
 
 analyzer = MedicalReportAnalyzer()
@@ -1415,6 +1410,7 @@ app.add_middleware(
 
 app.mount("/static", StaticFiles(directory="static"), name="static")
 
+
 @app.post("/process_user_report")
 async def process_user_report_endpoint(report_file: UploadFile = File(...)):
     try:
@@ -1438,6 +1434,7 @@ async def process_user_report_endpoint(report_file: UploadFile = File(...)):
             "message": str(e)
         }
 
+
 @app.get("/get_reference_ranges")
 def get_reference_ranges():
     return {
@@ -1445,6 +1442,7 @@ def get_reference_ranges():
         "data": STANDARD_RANGES
     }
 
+
 @app.post("/generate_suggestions")
 async def generate_suggestions(data: dict):
     try:
@@ -1460,6 +1458,7 @@ async def generate_suggestions(data: dict):
             "message": str(e)
         }
 
+
 @app.get("/metrics_comparison")
 def metrics_comparison(metric_name: str = Query(...)):
     try:
@@ -1474,6 +1473,7 @@ def metrics_comparison(metric_name: str = Query(...)):
             "message": str(e)
         }
 
+
 @app.get("/user_history/{user_id}")
 def get_user_history(user_id: str):
     try:
@@ -1488,6 +1488,7 @@ def get_user_history(user_id: str):
             "message": str(e)
         }
 
+
 @app.post("/save_report_data")
 async def save_report_data(data: dict):
     try:
@@ -1507,6 +1508,7 @@ async def save_report_data(data: dict):
             "message": str(e)
         }
 
+
 if __name__ == "__main__":
     import uvicorn