Create app.py

app.py

@@ -0,0 +1,216 @@
+from flask import Flask, request, jsonify, render_template, send_file
+import pandas as pd
+import numpy as np
+import joblib
+import sqlite3
+import io
+from datetime import datetime
+import xlsxwriter
+from flask_httpauth import HTTPBasicAuth
+
+app = Flask(__name__, template_folder='templates')
+
+auth = HTTPBasicAuth()
+
+# Load the trained model
+try:
+    model = joblib.load('stroke_prediction_model.pkl')
+    print("Model loaded successfully.")
+except Exception as e:
+    print(f"Error loading model: {str(e)}")
+    model = None
+
+   # Admin credentials for report access
+users = {
+       "admin": "your_secure_password"  # Replace with a strong password
+   }
+
+@auth.verify_password
+def verify_password(username, password):
+       if username in users and users[username] == password:
+           return username
+       return None
+
+   # Initialize SQLite database
+def init_db():
+       conn = sqlite3.connect('submissions.db')
+       c = conn.cursor()
+       c.execute('''
+           CREATE TABLE IF NOT EXISTS submissions (
+               id INTEGER PRIMARY KEY AUTOINCREMENT,
+               timestamp TEXT,
+               age REAL,
+               gender TEXT,
+               ever_married TEXT,
+               residence_type TEXT,
+               work_type TEXT,
+               hypertension INTEGER,
+               heart_disease INTEGER,
+               avg_glucose_level REAL,
+               bmi REAL,
+               smoking_status TEXT,
+               probability INTEGER,
+               risk_level TEXT
+           )
+       ''')
+       conn.commit()
+       conn.close()
+
+init_db()
+
+@app.route('/')
+def home():
+       return render_template('index.html')
+
+@app.route('/predict', methods=['POST'])
+def predict():
+       if model is None:
+           return jsonify({'success': False, 'error': 'Model failed to load'}), 500
+
+       try:
+           # Get form data
+           data = request.json
+           if not data or 'input' not in data:
+               return jsonify({'success': False, 'error': 'Invalid input data'}), 400
+           input_data = data['input']
+           print(f"Received input data: {input_data}")
+
+           # Prepare data for model
+           features = {
+               'age': float(input_data.get('age', 0)),
+               'gender': input_data.get('gender', 'Unknown'),
+               'ever_married': input_data.get('ever_married', 'No'),
+               'Residence_type': input_data.get('residence_type', 'Unknown'),
+               'work_type': input_data.get('work_type', 'Unknown'),
+               'hypertension': int(input_data.get('hypertension', 0)),
+               'heart_disease': int(input_data.get('heart_disease', 0)),
+               'avg_glucose_level': float(input_data.get('avg_glucose_level', 0)),
+               'bmi': float(input_data.get('bmi', 0)),
+               'smoking_status': input_data.get('smoking_status', 'Unknown')
+           }
+           print(f"Processed features: {features}")
+
+           # Convert to DataFrame
+           df = pd.DataFrame([features])
+
+           # One-hot encode categorical variables
+           categorical_cols = ['gender', 'ever_married', 'Residence_type', 'work_type', 'smoking_status']
+           df = pd.get_dummies(df, columns=categorical_cols, drop_first=True)
+
+           # Get expected columns from the model
+           expected_columns = model.feature_names_in_ if hasattr(model, 'feature_names_in_') else [
+               'age', 'hypertension', 'heart_disease', 'avg_glucose_level', 'bmi',
+               'gender_Male', 'gender_Other', 'ever_married_Yes', 'Residence_type_Urban',
+               'work_type_Govt_job', 'work_type_Never_worked', 'work_type_Private',
+               'work_type_Self-employed',
+               'smoking_status_formerly smoked', 'smoking_status_never smoked',
+               'smoking_status_smokes'
+           ]
+           print(f"Expected columns: {expected_columns}")
+
+           # Align DataFrame with expected columns
+           for col in expected_columns:
+               if col not in df.columns:
+                   df[col] = 0
+           df = df[expected_columns]
+
+           # Make prediction
+           probability = model.predict_proba(df)[0][1] * 100  # Probability of stroke
+           risk_level = 'High' if probability > 50 else 'Moderate' if probability > 25 else 'Low'
+
+           # Determine contributing factors
+           contributing_factors = {
+               'age': features['age'] > 45,
+               'hypertension': features['hypertension'] == 1,
+               'heart_disease': features['heart_disease'] == 1,
+               'glucose': features['avg_glucose_level'] > 140,
+               'smoking': features['smoking_status'] in ['smokes', 'formerly smoked']
+           }
+
+           # Log submission to database
+           conn = sqlite3.connect('submissions.db')
+           c = conn.cursor()
+           c.execute('''
+               INSERT INTO submissions (
+                   timestamp, age, gender, ever_married, residence_type, work_type,
+                   hypertension, heart_disease, avg_glucose_level, bmi, smoking_status,
+                   probability, risk_level
+               ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)
+           ''', (
+               datetime.now().isoformat(),
+               features['age'],
+               features['gender'],
+               features['ever_married'],
+               features['Residence_type'],
+               features['work_type'],
+               features['hypertension'],
+               features['heart_disease'],
+               features['avg_glucose_level'],
+               features['bmi'],
+               features['smoking_status'],
+               round(probability),
+               risk_level
+           ))
+           conn.commit()
+           conn.close()
+
+           # Return prediction result
+           return jsonify({
+               'success': True,
+               'probability': round(probability),
+               'riskLevel': risk_level,
+               'contributingFactors': contributing_factors
+           })
+       except Exception as e:
+           print(f"Error during prediction: {str(e)}")
+           return jsonify({'success': False, 'error': str(e)}), 500
+
+@app.route('/admin/report', methods=['GET'])
+@auth.login_required
+def admin_report():
+       try:
+           today = datetime.now().strftime('%Y-%m-%d')
+           conn = sqlite3.connect('submissions.db')
+           df = pd.read_sql_query('SELECT * FROM submissions WHERE DATE(timestamp) = ?', conn, params=[today])
+           conn.close()
+           
+           if df.empty:
+               return "No submissions for today.", 200
+           
+           # Prepare data for Excel
+           df['hypertension'] = df['hypertension'].apply(lambda x: 'Yes' if x == 1 else 'No')
+           df['heart_disease'] = df['heart_disease'].apply(lambda x: 'Yes' if x == 1 else 'No')
+           df = df[[
+               'timestamp', 'age', 'gender', 'ever_married', 'residence_type', 'work_type',
+               'hypertension', 'heart_disease', 'avg_glucose_level', 'bmi', 'smoking_status',
+               'probability', 'risk_level'
+           ]]
+           df.columns = [
+               'Timestamp', 'Age', 'Gender', 'Ever Married', 'Residence Type', 'Work Type',
+               'Hypertension', 'Heart Disease', 'Avg Glucose Level', 'BMI', 'Smoking Status',
+               'Probability (%)', 'Risk Level'
+           ]
+           
+           # Create Excel file in memory
+           output = io.BytesIO()
+           with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
+               df.to_excel(writer, sheet_name='Daily Report', index=False)
+               worksheet = writer.sheets['Daily Report']
+               for idx, col in enumerate(df.columns):
+                   max_len = max(df[col].astype(str).map(len).max(), len(col)) + 2
+                   worksheet.set_column(idx, idx, max_len)
+           output.seek(0)
+           
+           # Send file
+           return send_file(
+               output,
+               download_name=f'report_{today}.xlsx',
+               as_attachment=True,
+               mimetype='application/vnd.openxmlformats-officedocument.spreadsheetml.sheet'
+           )
+       except Exception as e:
+           print(f"Error generating report: {str(e)}")
+           return f"Error generating report: {str(e)}", 500
+
+if __name__ == '__main__':
+       app.run(debug=True, host='0.0.0.0', port=5000)