app.py

from flask import Flask, render_template, request, redirect, url_for, flash, session, jsonify, send_from_directory
import numpy as np
import pandas as pd
import joblib
from sklearn.preprocessing import StandardScaler
from datetime import datetime
import os
import sqlite3
from sklearn.ensemble import RandomForestClassifier

app = Flask(__name__)
app.secret_key = 'your_secret_key'

# Load the diabetes prediction model and scaler
model = joblib.load('diabetes_model.pkl')
scaler = joblib.load('scaler.pkl')

# Load models for detailed health check
cardio_model = joblib.load('cardio_model.pkl')
nephropathy_model = joblib.load('nephropathy_model.pkl')
neuropathy_model = joblib.load('neuropathy_model.pkl')
retinopathy_model = joblib.load('retinopathy_model.pkl')
liver_model = joblib.load('liver_model.pkl')

# Initialize database
def init_db():
    conn = sqlite3.connect('predictions.db')
    c = conn.cursor()
    c.execute('''CREATE TABLE IF NOT EXISTS predictions
                 (id INTEGER PRIMARY KEY AUTOINCREMENT,
                  timestamp TEXT,
                  prediction INTEGER,
                  probability REAL,
                  features TEXT)''')
    conn.commit()
    conn.close()

init_db()

@app.route('/')
def home():
    if os.path.exists(os.path.join(app.static_folder, 'react', 'index.html')):
        return send_from_directory(os.path.join(app.static_folder, 'react'), 'index.html')
    return render_template('input.html')

@app.route('/assets/<path:path>')
def serve_react_assets(path):
    return send_from_directory(os.path.join(app.static_folder, 'react', 'assets'), path)

@app.route('/favicon.svg')
def serve_react_favicon():
    return send_from_directory(os.path.join(app.static_folder, 'react'), 'favicon.svg')

@app.route('/icons.svg')
def serve_react_icons():
    return send_from_directory(os.path.join(app.static_folder, 'react'), 'icons.svg')

@app.route('/predict', methods=['POST'])
def predict():
    try:
        # Extract features from form
        features = [
            float(request.form['glucose']),
            float(request.form['blood_pressure']),
            float(request.form['skin_thickness']),
            float(request.form['insulin']),
            float(request.form['bmi']),
            float(request.form['waist_circumference']),
            float(request.form['diabetes_pedigree']),
            float(request.form['age'])
        ]
        
        # Define normal ranges for each feature
        normal_ranges = {
            'glucose': {'min': 70, 'max': 140},  # Normal fasting glucose range
            'blood_pressure': {'min': 60, 'max': 90},  # Normal diastolic BP range
            'skin_thickness': {'min': 10, 'max': 50},  # Normal skin thickness range
            'insulin': {'min': 20, 'max': 200},  # Normal insulin range
            'bmi': {'min': 18.5, 'max': 24.9},  # Normal BMI range
            'waist_circumference': {'min': 60, 'max': 100},  # Normal waist circumference range
            'diabetes_pedigree': {'min': 0.1, 'max': 1.0},  # Normal pedigree function range
            'age': {'min': 18, 'max': 65}  # Normal age range for assessment
        }
        
        # Calculate risk score based on ranges
        risk_score = 0
        total_factors = len(features)
        
        # Check each feature against normal ranges
        for i, (feature_name, value) in enumerate(zip(normal_ranges.keys(), features)):
            normal_min = normal_ranges[feature_name]['min']
            normal_max = normal_ranges[feature_name]['max']
            
            # Calculate how far the value is from normal range
            if value < normal_min:
                # Calculate risk based on how far below normal
                deviation = (normal_min - value) / normal_min
                risk_score += min(deviation, 1.0)  # Cap at 1.0
            elif value > normal_max:
                # Calculate risk based on how far above normal
                deviation = (value - normal_max) / normal_max
                risk_score += min(deviation, 1.0)  # Cap at 1.0
        
        # Calculate average risk score
        average_risk = risk_score / total_factors
        
        # Scale features for model prediction
        features_scaled = scaler.transform([features])
        
        # Get model prediction
        model_prediction = int(model.predict(features_scaled)[0])
        model_probability = float(model.predict_proba(features_scaled)[0][1] * 100)
        
        # Combine model prediction with range-based risk
        if average_risk > 0.5 or model_probability > 60:  # High risk if either condition is met
            prediction = 1
            probability = max(average_risk * 100, model_probability)
        else:
            prediction = 0
            probability = min((1 - average_risk) * 100, 100 - model_probability)
        
        # Save to database
        conn = sqlite3.connect('predictions.db')
        c = conn.cursor()
        c.execute('INSERT INTO predictions (timestamp, prediction, probability, features) VALUES (?, ?, ?, ?)',
                 (datetime.now().strftime('%Y-%m-%d %H:%M:%S'), prediction, probability, str(features)))
        conn.commit()
        conn.close()
        
        # Render the result template with prediction and probability
        return render_template('result.html', 
                             prediction=prediction, 
                             probability=round(probability, 2))
    except Exception as e:
        print(f"Error in predict route: {str(e)}")  # Add debug logging
        flash(f'Error: {str(e)}')
        return redirect(url_for('home'))

@app.route('/result')
def result():
    # Get the latest prediction from the database
    conn = sqlite3.connect('predictions.db')
    c = conn.cursor()
    c.execute('SELECT prediction, probability FROM predictions ORDER BY timestamp DESC LIMIT 1')
    result = c.fetchone()
    conn.close()
    
    if result:
        prediction, probability = result
        return render_template('result.html', 
                             prediction=prediction, 
                             probability=round(probability, 2))
    else:
        flash('No prediction results found')
        return redirect(url_for('home'))

@app.route('/detailed-result')
def detailed_result():
    # This route seems to be based on the detailed_predictions table, which we decided to remove for now.
    # We will rely on the session for the latest detailed prediction results.
    flash('This route is currently inactive.')
    return redirect(url_for('detailed_check'))

@app.route('/detailed-check', methods=['GET'])
def detailed_check():
    return render_template('detailed_check.html')

@app.route('/run-detailed-prediction', methods=['POST'])
def run_detailed_prediction():
    print("=== Reached run_detailed_prediction route ===")
    try:
        # Extract features for each condition with default values of 0 for empty fields
        cardio_features = [
            float(request.form.get('chest_pain', 0)),
            float(request.form.get('shortness_breath', 0)),
            float(request.form.get('irregular_heartbeat', 0)),
            float(request.form.get('swelling_legs', 0)),
            float(request.form.get('fatigue', 0)),
            float(request.form.get('blood_pressure', 0) or 0),  # Handle empty string
            float(request.form.get('cholesterol', 0) or 0)  # Handle empty string
        ]
        
        nephropathy_features = [
            float(request.form.get('proteinuria', 0)),
            float(request.form.get('swelling_ankles', 0)),
            float(request.form.get('fatigue_neph', 0)),
            float(request.form.get('nausea', 0)),
            float(request.form.get('creatinine_level', 0) or 0),  # Handle empty string
            float(request.form.get('urine_output', 0) or 0)  # Handle empty string
        ]
        
        retinopathy_features = [
            float(request.form.get('blurred_vision', 0)),
            float(request.form.get('floaters', 0)),
            float(request.form.get('dark_spots', 0)),
            float(request.form.get('vision_loss', 0)),
            float(request.form.get('eye_pain', 0)),
            float(request.form.get('glucose_level', 0) or 0),  # Handle empty string
            float(request.form.get('duration_diabetes', 0) or 0)  # Handle empty string
        ]
         
        neuropathy_features = [
            float(request.form.get('numbness', 0)),
            float(request.form.get('tingling', 0)),
            float(request.form.get('burning_pain', 0)),
            float(request.form.get('muscle_weakness', 0)),
            float(request.form.get('balance_problems', 0))
        ]
        
        liver_features = [
            float(request.form.get('abdominal_pain', 0)),
            float(request.form.get('fatigue_liver', 0)),
            float(request.form.get('nausea_liver', 0)),
            float(request.form.get('jaundice', 0)),
            float(request.form.get('swelling_abdomen', 0)),
            float(request.form.get('ast_level', 0) or 0),  # Handle empty string
            float(request.form.get('alt_level', 0) or 0)  # Handle empty string
        ]
        
        # Make predictions for each condition
        cardio_risk = int(cardio_model.predict([cardio_features])[0])
        cardio_probability = float(cardio_model.predict_proba([cardio_features])[0][1] * 100)
        
        nephropathy_risk = int(nephropathy_model.predict([nephropathy_features])[0])
        nephropathy_probability = float(nephropathy_model.predict_proba([nephropathy_features])[0][1] * 100)
        
        retinopathy_risk = int(retinopathy_model.predict([retinopathy_features])[0])
        retinopathy_probability = float(retinopathy_model.predict_proba([retinopathy_features])[0][1] * 100)
        
        neuropathy_risk = int(neuropathy_model.predict([neuropathy_features])[0])
        neuropathy_probability = float(neuropathy_model.predict_proba([neuropathy_features])[0][1] * 100)
        
        liver_risk = int(liver_model.predict([liver_features])[0])
        liver_probability = float(liver_model.predict_proba([liver_features])[0][1] * 100)
        
        # Store results in session
        session['detailed_results'] = {
            'cardio_risk': cardio_risk,
            'cardio_probability': round(cardio_probability, 2),
            'nephropathy_risk': nephropathy_risk,
            'nephropathy_probability': round(nephropathy_probability, 2),
            'retinopathy_risk': retinopathy_risk,
            'retinopathy_probability': round(retinopathy_probability, 2),
            'neuropathy_risk': neuropathy_risk,
            'neuropathy_probability': round(neuropathy_probability, 2),
            'liver_risk': liver_risk,
            'liver_probability': round(liver_probability, 2)
        }
        
        # Redirect to the new view-last-detailed-report route
        return redirect(url_for('view_last_detailed_report'))
        
    except Exception as e:
        import traceback
        print("\n=== Error in run_detailed_prediction route ===")
        traceback.print_exc()
        print("===========================================")
        flash(f'Error processing prediction: {str(e)}')
        return redirect(url_for('detailed_check'))

@app.route('/view-last-detailed-report')
def view_last_detailed_report():
    if 'detailed_results' in session:
        results = session['detailed_results']
        return render_template('detailed_report.html', **results)
    else:
        flash('No detailed health assessment results found. Please submit the form first.')
        return redirect(url_for('detailed_check'))

@app.route('/records')
def records():
    conn = sqlite3.connect('predictions.db')
    c = conn.cursor()
    c.execute('SELECT id, timestamp, prediction, probability, features FROM predictions ORDER BY timestamp DESC')
    records = []
    for row in c.fetchall():
        records.append({
            'id': row[0],
            'timestamp': row[1],
            'prediction': row[2],
            'probability': row[3],
            'features': row[4]
        })
    conn.close()
    return render_template('records.html', records=records)

@app.route('/delete_record/<int:record_id>', methods=['POST'])
def delete_record(record_id):
    try:
        conn = sqlite3.connect('predictions.db')
        c = conn.cursor()
        c.execute('DELETE FROM predictions WHERE id = ?', (record_id,))
        conn.commit()
        conn.close()
        flash('Record deleted successfully')
    except Exception as e:
        flash(f'Error deleting record: {str(e)}')
    return redirect(url_for('records'))

# ==================== REACT JSON API ENDPOINTS ====================

@app.route('/api/predict', methods=['POST'])
def api_predict():
    try:
        data = request.json
        features = [
            float(data['glucose']),
            float(data['blood_pressure']),
            float(data['skin_thickness']),
            float(data['insulin']),
            float(data['bmi']),
            float(data['waist_circumference']),
            float(data['diabetes_pedigree']),
            float(data['age'])
        ]
        
        normal_ranges = {
            'glucose': {'min': 70, 'max': 140},
            'blood_pressure': {'min': 60, 'max': 90},
            'skin_thickness': {'min': 10, 'max': 50},
            'insulin': {'min': 20, 'max': 200},
            'bmi': {'min': 18.5, 'max': 24.9},
            'waist_circumference': {'min': 60, 'max': 100},
            'diabetes_pedigree': {'min': 0.1, 'max': 1.0},
            'age': {'min': 18, 'max': 65}
        }
        
        risk_score = 0
        total_factors = len(features)
        
        for i, (feature_name, value) in enumerate(zip(normal_ranges.keys(), features)):
            normal_min = normal_ranges[feature_name]['min']
            normal_max = normal_ranges[feature_name]['max']
            if value < normal_min:
                deviation = (normal_min - value) / normal_min
                risk_score += min(deviation, 1.0)
            elif value > normal_max:
                deviation = (value - normal_max) / normal_max
                risk_score += min(deviation, 1.0)
        
        average_risk = risk_score / total_factors
        features_scaled = scaler.transform([features])
        model_prediction = int(model.predict(features_scaled)[0])
        model_probability = float(model.predict_proba(features_scaled)[0][1] * 100)
        
        if average_risk > 0.5 or model_probability > 60:
            prediction = 1
            probability = max(average_risk * 100, model_probability)
        else:
            prediction = 0
            probability = min((1 - average_risk) * 100, 100 - model_probability)
        
        # Save to database
        conn = sqlite3.connect('predictions.db')
        c = conn.cursor()
        c.execute('INSERT INTO predictions (timestamp, prediction, probability, features) VALUES (?, ?, ?, ?)',
                 (datetime.now().strftime('%Y-%m-%d %H:%M:%S'), prediction, probability, str(features)))
        conn.commit()
        conn.close()
        
        return jsonify({
            'status': 'success',
            'prediction': prediction,
            'probability': round(probability, 2)
        })
    except Exception as e:
        return jsonify({'status': 'error', 'message': str(e)}), 400

@app.route('/api/records', methods=['GET'])
def api_records():
    try:
        conn = sqlite3.connect('predictions.db')
        c = conn.cursor()
        c.execute('SELECT id, timestamp, prediction, probability, features FROM predictions ORDER BY timestamp DESC')
        records = []
        for row in c.fetchall():
            records.append({
                'id': row[0],
                'timestamp': row[1],
                'prediction': row[2],
                'probability': round(row[3], 2),
                'features': row[4]
            })
        conn.close()
        return jsonify({'status': 'success', 'records': records})
    except Exception as e:
        return jsonify({'status': 'error', 'message': str(e)}), 400

@app.route('/api/delete_record/<int:record_id>', methods=['POST'])
def api_delete_record(record_id):
    try:
        conn = sqlite3.connect('predictions.db')
        c = conn.cursor()
        c.execute('DELETE FROM predictions WHERE id = ?', (record_id,))
        conn.commit()
        conn.close()
        return jsonify({'status': 'success', 'message': 'Record deleted successfully'})
    except Exception as e:
        return jsonify({'status': 'error', 'message': str(e)}), 400

@app.route('/api/run-detailed-prediction', methods=['POST'])
def api_run_detailed_prediction():
    try:
        data = request.json
        cardio_features = [
            float(data.get('chest_pain', 0)),
            float(data.get('shortness_breath', 0)),
            float(data.get('irregular_heartbeat', 0)),
            float(data.get('swelling_legs', 0)),
            float(data.get('fatigue', 0)),
            float(data.get('blood_pressure', 0) or 0),
            float(data.get('cholesterol', 0) or 0)
        ]
        
        nephropathy_features = [
            float(data.get('proteinuria', 0)),
            float(data.get('swelling_ankles', 0)),
            float(data.get('fatigue_neph', 0)),
            float(data.get('nausea', 0)),
            float(data.get('creatinine_level', 0) or 0),
            float(data.get('urine_output', 0) or 0)
        ]
        
        retinopathy_features = [
            float(data.get('blurred_vision', 0)),
            float(data.get('floaters', 0)),
            float(data.get('dark_spots', 0)),
            float(data.get('vision_loss', 0)),
            float(data.get('eye_pain', 0)),
            float(data.get('glucose_level', 0) or 0),
            float(data.get('duration_diabetes', 0) or 0)
        ]
         
        neuropathy_features = [
            float(data.get('numbness', 0)),
            float(data.get('tingling', 0)),
            float(data.get('burning_pain', 0)),
            float(data.get('muscle_weakness', 0)),
            float(data.get('balance_problems', 0))
        ]
        
        liver_features = [
            float(data.get('abdominal_pain', 0)),
            float(data.get('fatigue_liver', 0)),
            float(data.get('nausea_liver', 0)),
            float(data.get('jaundice', 0)),
            float(data.get('swelling_abdomen', 0)),
            float(data.get('ast_level', 0) or 0),
            float(data.get('alt_level', 0) or 0)
        ]
        
        cardio_risk = int(cardio_model.predict([cardio_features])[0])
        cardio_probability = float(cardio_model.predict_proba([cardio_features])[0][1] * 100)
        
        nephropathy_risk = int(nephropathy_model.predict([nephropathy_features])[0])
        nephropathy_probability = float(nephropathy_model.predict_proba([nephropathy_features])[0][1] * 100)
        
        retinopathy_risk = int(retinopathy_model.predict([retinopathy_features])[0])
        retinopathy_probability = float(retinopathy_model.predict_proba([retinopathy_features])[0][1] * 100)
        
        neuropathy_risk = int(neuropathy_model.predict([neuropathy_features])[0])
        neuropathy_probability = float(neuropathy_model.predict_proba([neuropathy_features])[0][1] * 100)
        
        liver_risk = int(liver_model.predict([liver_features])[0])
        liver_probability = float(liver_model.predict_proba([liver_features])[0][1] * 100)
        
        return jsonify({
            'status': 'success',
            'results': {
                'cardio_risk': cardio_risk,
                'cardio_probability': round(cardio_probability, 2),
                'nephropathy_risk': nephropathy_risk,
                'nephropathy_probability': round(nephropathy_probability, 2),
                'retinopathy_risk': retinopathy_risk,
                'retinopathy_probability': round(retinopathy_probability, 2),
                'neuropathy_risk': neuropathy_risk,
                'neuropathy_probability': round(neuropathy_probability, 2),
                'liver_risk': liver_risk,
                'liver_probability': round(liver_probability, 2)
            }
        })
    except Exception as e:
        return jsonify({'status': 'error', 'message': str(e)}), 400

if __name__ == '__main__':
    app.run(debug=True)