Refactor project structure and improve code organization

- Reorganized code into a proper Python package structure
- Added comprehensive configuration management
- Improved error handling and logging
- Added type hints and docstrings
- Set up testing infrastructure
- Updated README with better documentation
- Added setup.py for package installation
- Cleaned up unnecessary files

.gitignore

@@ -0,0 +1,54 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Virtual Environment
+venv/
+env/
+ENV/
+
+# IDE
+.idea/
+.vscode/
+*.swp
+*.swo
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# Environment variables
+.env
+
+# Model files
+models/
+!src/diabetes_prediction/models/.gitkeep
+
+# Logs
+logs/
+*.log
+
+# Local development
+.DS_Store
+
+# Testing
+.coverage
+htmlcov/
+.pytest_cache/

README.md

@@ -1,5 +1,8 @@
 ---
-title: Diabetes Prediction
+title: Diabetes Prediction App
+
+A Streamlit web application that predicts the likelihood of diabetes based on patient data using a Gradient Boosting Classifier.
+
 emoji: 🚀
 colorFrom: red
 colorTo: red

app.py

@@ -1,447 +0,0 @@
-import os
-import sys
-import logging
-from pathlib import Path
-
-import streamlit as st
-import pandas as pd
-import numpy as np
-import matplotlib.pyplot as plt
-import seaborn as sns
-from sklearn.model_selection import train_test_split, cross_val_score
-from sklearn.ensemble import GradientBoostingClassifier
-from sklearn.preprocessing import StandardScaler
-from sklearn.pipeline import Pipeline
-from sklearn.metrics import accuracy_score, classification_report, confusion_matrix, f1_score
-import joblib
-from dotenv import load_dotenv
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.StreamHandler(sys.stdout)
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# Load environment variables (ignore if .env doesn't exist)
-load_dotenv(verbose=False)
-
-# Constants
-MODEL_DIR = Path('models')
-MODEL_PATH = MODEL_DIR / 'model.joblib'
-DATA_PATH = Path('diabetes.csv')
-RANDOM_STATE = 42  # For reproducible results
-
-def setup_environment():
-    """Set up the application environment."""
-    # Ensure models directory exists
-    MODEL_DIR.mkdir(parents=True, exist_ok=True)
-    logger.info("Environment setup complete")
-
-def load_data():
-    """Load and return the diabetes dataset or use sample data if not found."""
-    try:
-        # Try to load the CSV file
-        csv_paths = [
-            'diabetes.csv',
-            '/app/diabetes.csv',
-            'data/diabetes.csv',
-            '/app/data/diabetes.csv'
-        ]
-        
-        for path in csv_paths:
-            try:
-                if os.path.exists(path):
-                    df = pd.read_csv(path)
-                    logger.info(f"Successfully loaded data from {os.path.abspath(path)}")
-                    return df
-            except Exception as e:
-                logger.warning(f"Error reading {path}: {e}")
-                continue
-        
-        # If we get here, no file was found - use sample data
-        logger.warning("Using sample data as fallback")
-        sample_data = {
-            'Pregnancies': [6, 1, 8, 1, 0],
-            'Glucose': [148, 85, 183, 89, 137],
-            'BloodPressure': [72, 66, 64, 66, 40],
-            'SkinThickness': [35, 29, 0, 23, 35],
-            'Insulin': [0, 0, 0, 94, 168],
-            'BMI': [33.6, 26.6, 23.3, 28.1, 43.1],
-            'DiabetesPedigreeFunction': [0.627, 0.351, 0.672, 0.167, 2.288],
-            'Age': [50, 31, 32, 21, 33],
-            'Outcome': [1, 0, 1, 0, 1]
-        }
-        return pd.DataFrame(sample_data)
-        
-    except Exception as e:
-        logger.error(f"Error loading data: {e}")
-        raise
-
-def preprocess_data(df):
-    """Preprocess the input DataFrame."""
-    try:
-        # Make a copy to avoid SettingWithCopyWarning
-        df = df.copy()
-        
-        # Check if 'Outcome' column exists (it won't in the sample data)
-        target_col = 'Outcome' if 'Outcome' in df.columns else None
-        
-        # Replace zeros with mean values for numerical columns
-        numerical_cols = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
-        for col in numerical_cols:
-            if col in df.columns:
-                if target_col:
-                    df[col] = replace_zero(df, col, target_col)
-                else:
-                    # For sample data, just replace zeros with column mean
-                    df[col] = df[col].replace(0, df[col].mean())
-        
-        # Log the preprocessed data
-        logger.info("Data preprocessing completed")
-        logger.info(f"DataFrame shape: {df.shape}")
-        logger.info(f"Columns: {df.columns.tolist()}")
-        logger.info(df.head())
-        
-        return df
-    except Exception as e:
-        logger.error(f"Error in preprocess_data: {e}")
-        raise
-
-def replace_zero(df, field, target):
-    """Replace zeros with mean values grouped by the target variable."""
-    try:
-        # If target column doesn't exist, just replace zeros with column mean
-        if target not in df.columns:
-            return df[field].replace(0, df[df[field] != 0][field].mean())
-            
-        # Calculate mean by target class for non-zero values
-        non_zero = df[df[field] != 0]
-        if len(non_zero) == 0:  # If all values are zero
-            return df[field]
-            
-        mean_by_target = non_zero.groupby(target)[field].mean()
-        
-        # Create a copy to avoid SettingWithCopyWarning
-        result = df[field].copy()
-        
-        # Replace zeros with the mean of the corresponding target class
-        for target_value in df[target].unique():
-            if target_value in mean_by_target:  # Check if we have a mean for this target
-                mask = (df[field] == 0) & (df[target] == target_value)
-                if mask.any():
-                    result.loc[mask] = mean_by_target[target_value]
-            
-        return result
-    except Exception as e:
-        logger.error(f"Error replacing zeros in {field}: {e}")
-        # Fall back to simple mean if there's an error
-        return df[field].replace(0, df[df[field] != 0][field].mean() if len(df[df[field] != 0]) > 0 else 0)
-
-def train_model(X, y):
-    """Train and return the Gradient Boosting model."""
-    try:
-        # Gradient Boosting with optimized parameters
-        gb_params = {
-            'n_estimators': 290,
-            'max_depth': 9,
-            'subsample': 0.5,
-            'learning_rate': 0.01,
-            'min_samples_leaf': 1,
-            'random_state': RANDOM_STATE
-        }
-        
-        # Create pipeline with preprocessing and model
-        pipeline = Pipeline([
-            ('scaler', StandardScaler()),
-            ('classifier', GradientBoostingClassifier(**gb_params))
-        ])
-        
-        # Train the model
-        pipeline.fit(X, y)
-        logger.info("Model training completed successfully")
-        return pipeline
-    except Exception as e:
-        logger.error(f"Error during model training: {e}")
-        raise
-
-def save_model(model):
-    """Save the trained model to disk."""
-    try:
-        joblib.dump(model, MODEL_PATH)
-        logger.info(f"Model saved to {MODEL_PATH}")
-    except Exception as e:
-        logger.error(f"Error saving model: {e}")
-        raise
-
-def load_saved_model():
-    """Load a previously saved model from disk or return None to train a new one."""
-    # Always return None to force training a new model
-    # This is because we can't guarantee the model file exists in the deployment
-    return None
-
-def get_user_input():
-    """Get input features from the user via the sidebar."""
-    st.sidebar.header('Patient Information')
-    
-    # Group related features
-    with st.sidebar.expander("Personal Information"):
-        pregnancies = st.slider('Pregnancies', 0, 17, 3)
-        age = st.slider('Age', 21, 81, 29)
-    
-    with st.sidebar.expander("Medical Measurements"):
-        col1, col2 = st.columns(2)
-        with col1:
-            glucose = st.slider('Glucose (mg/dL)', 0, 200, 120)
-            bp = st.slider('Blood Pressure (mmHg)', 0, 122, 70)
-            skin_thickness = st.slider('Skin Thickness (mm)', 0, 100, 20)
-        with col2:
-            insulin = st.slider('Insulin (μU/mL)', 0, 846, 79)
-            bmi = st.slider('BMI', 0.0, 67.1, 32.0)
-            dpf = st.slider('Diabetes Pedigree', 0.0, 2.42, 0.3725, 0.01)
-    
-    # Create feature dictionary
-    user_data = {
-        'Pregnancies': pregnancies,
-        'Glucose': glucose,
-        'BloodPressure': bp,
-        'SkinThickness': skin_thickness,
-        'Insulin': insulin,
-        'BMI': bmi,
-        'DiabetesPedigreeFunction': dpf,
-        'Age': age
-    }
-    
-    return pd.DataFrame(user_data, index=[0])
-
-def main():
-    """Main application function."""
-    try:
-        # Set page config
-        st.set_page_config(
-            page_title="Diabetes Prediction App",
-            page_icon="🩺",
-            layout="wide",
-            initial_sidebar_state="expanded"
-        )
-        
-        # Setup environment - create models directory if it doesn't exist
-        try:
-            os.makedirs('models', exist_ok=True)
-        except Exception as e:
-            st.warning(f"Could not create models directory: {e}")
-        
-        # Show loading message
-        with st.spinner('Loading and preprocessing data...'):
-            try:
-                df = load_data()
-                df = preprocess_data(df)
-                X = df.drop(['Outcome'], axis=1)
-                y = df['Outcome']
-                
-                # Split the data
-                X_train, X_test, y_train, y_test = train_test_split(
-                    X, y, test_size=0.2, random_state=RANDOM_STATE
-                )
-            except Exception as e:
-                st.error(f"Error loading data: {str(e)}")
-                st.stop()
-        
-        # Always train a new model (since we can't upload model files)
-        with st.spinner('Training model (this may take a minute)...'):
-            try:
-                model = train_model(X_train, y_train)
-                # Don't save the model to avoid permission issues
-                st.success("Model training completed successfully!")
-            except Exception as e:
-                st.error(f"Error training model: {str(e)}")
-                st.stop()
-        
-        # Main app layout
-        st.title('Diabetes Risk Assessment')
-        st.markdown("""
-        This application uses machine learning to predict the likelihood of diabetes 
-        based on patient health metrics. Enter the patient's information in the sidebar 
-        and click 'Predict' to see the results.
-        """)
-        
-        # Get user input and display it
-        try:
-            user_data = get_user_input()
-            
-            # Display user input in main area
-            with st.expander("View Patient Data"):
-                st.dataframe(user_data.style.format({
-                    'Pregnancies': '{:.0f}',
-                    'Glucose': '{:.0f} mg/dL',
-                    'BloodPressure': '{:.0f} mm Hg',
-                    'SkinThickness': '{:.0f} mm',
-                    'Insulin': '{:.0f} mu U/ml',
-                    'BMI': '{:.1f} kg/m²',
-                    'DiabetesPedigreeFunction': '{:.3f}',
-                    'Age': '{:.0f} years'
-                }))
-                
-                # Make prediction when user clicks the button
-                if st.button('Predict Diabetes Risk'):
-                    with st.spinner('Analyzing...'):
-                        prediction = model.predict(user_data)
-                        prediction_proba = model.predict_proba(user_data)
-                        
-                        # Display results
-                        st.subheader('Prediction Results')
-                        col1, col2 = st.columns(2)
-                        with col1:
-                            st.metric(
-                                "Risk of Diabetes",
-                                "High Risk" if prediction[0] == 1 else "Low Risk",
-                                f"{prediction_proba[0][1] * 100:.2f}%"
-                            )
-                        with col2:
-                            st.metric(
-                                "Confidence",
-                                f"{np.max(prediction_proba) * 100:.1f}%",
-                                "in prediction"
-                            )
-                            
-                        # Display feature importance
-                        st.subheader('Feature Importance')
-                        if hasattr(model, 'feature_importances_'):
-                            feature_importance = pd.DataFrame({
-                                'Feature': X_train.columns,
-                                'Importance': model.feature_importances_
-                            }).sort_values('Importance', ascending=False)
-                            
-                            fig, ax = plt.subplots(figsize=(10, 6))
-                            sns.barplot(
-                                x='Importance', 
-                                y='Feature', 
-                                data=feature_importance,
-                                palette='viridis'
-                            )
-                            plt.title('Feature Importance')
-                            plt.tight_layout()
-                            st.pyplot(fig)
-                            
-        except Exception as e:
-            st.error(f"An error occurred: {str(e)}")
-            logger.error(f"Error in main app: {str(e)}", exc_info=True)
-        # Make prediction
-        if st.sidebar.button('Predict', type='primary'):
-            with st.spinner('Analyzing...'):
-                # Make prediction
-                prediction = model.predict(user_data)
-                proba = model.predict_proba(user_data)[0]
-                
-                # Display prediction with emoji and styling
-                st.markdown("## Prediction Result")
-                if prediction[0] == 1:
-                    st.error('⚠️ **High Risk of Diabetes**')
-                    st.warning("""
-                    Based on the provided information, this patient shows indicators associated 
-                    with a higher risk of diabetes. We recommend consulting with a healthcare 
-                    professional for further evaluation.
-                    """)
-                else:
-                    st.success('✅ **Low Risk of Diabetes**')
-                    st.info("""
-                    Based on the provided information, this patient shows indicators associated 
-                    with a lower risk of diabetes. However, regular check-ups are recommended 
-                    for maintaining good health.
-                    """)
-                
-                # Show probability with a progress bar
-                risk_percent = proba[1] * 100
-                st.metric("Risk Score", f"{risk_percent:.1f}%")
-                st.progress(risk_percent / 100)
-                
-                # Model performance
-                st.markdown("## Model Performance")
-                
-                # Cross-validated metrics
-                with st.expander("Performance Metrics"):
-                    col1, col2 = st.columns(2)
-                    
-                    # Cross-validated F1
-                    with col1:
-                        cv_scores = cross_val_score(model, X, y, cv=5, scoring='f1')
-                        st.metric(
-                            "Cross-validated F1-score",
-                            f"{cv_scores.mean():.3f}",
-                            f"±{cv_scores.std():.3f}"
-                        )
-                    
-                    # Test set metrics
-                    with col2:
-                        y_pred = model.predict(X_test)
-                        test_accuracy = accuracy_score(y_test, y_pred)
-                        st.metric(
-                            "Test Set Accuracy",
-                            f"{test_accuracy*100:.1f}%"
-                        )
-                
-                # Feature importance
-                st.markdown("## Feature Importance")
-                importances = model.named_steps['classifier'].feature_importances_
-                feature_importance = pd.DataFrame({
-                    'Feature': X.columns,
-                    'Importance': importances
-                }).sort_values('Importance', ascending=True)
-                
-                # Horizontal bar chart for feature importance
-                fig, ax = plt.subplots(figsize=(10, 6))
-                ax.barh(feature_importance['Feature'], feature_importance['Importance'])
-                ax.set_xlabel('Importance Score')
-                ax.set_title('Relative Importance of Features in Prediction')
-                st.pyplot(fig)
-                
-                # Confusion matrix
-                st.markdown("## Confusion Matrix")
-                cm = confusion_matrix(y_test, y_pred)
-                fig, ax = plt.subplots()
-                sns.heatmap(
-                    cm, 
-                    annot=True, 
-                    fmt='d', 
-                    cmap='Blues', 
-                    ax=ax,
-                    xticklabels=['No Diabetes', 'Diabetes'],
-                    yticklabels=['No Diabetes', 'Diabetes']
-                )
-                ax.set_xlabel('Predicted')
-                ax.set_ylabel('Actual')
-                ax.set_title('Model Performance on Test Data')
-                st.pyplot(fig)
-                
-                # Add footer
-                st.markdown("---")
-                st.caption("""
-                **Note**: This tool is for informational purposes only and is not intended 
-                to replace professional medical advice, diagnosis, or treatment. Always seek 
-                the advice of your physician or other qualified health provider with any 
-                questions you may have regarding a medical condition.
-                """)
-    
-    except FileNotFoundError:
-        st.error("""
-        ### Error: Data File Not Found
-        The diabetes dataset could not be found. Please ensure that `diabetes.csv` 
-        is in the project directory.
-        """)
-        logger.error("diabetes.csv file not found")
-    except Exception as e:
-        st.error(f"""
-        ### An Unexpected Error Occurred
-        We apologize for the inconvenience. The application encountered an error:
-        
-        `{str(e)}`
-        
-        Please try refreshing the page or contact support if the issue persists.
-        """)
-        logger.exception("Unexpected error in main application")
-
-if __name__ == "__main__":
-    main()

requirements.txt

@@ -1,3 +1,4 @@
+# Core Dependencies
 streamlit>=1.32.0
 pandas>=2.1.4
 numpy>=1.26.3
@@ -6,7 +7,17 @@ matplotlib>=3.8.2
 seaborn>=0.13.2
 joblib>=1.3.2
 python-dotenv>=1.0.0
-Pillow>=10.4.0
-pydeck>=0.9.1
-protobuf>=4.25.8
-typing-extensions>=4.10.0
+
+# Testing
+pytest>=7.4.0
+pytest-cov>=4.1.0
+
+# Code Quality
+black>=23.7.0
+isort>=5.12.0
+flake8>=6.1.0
+mypy>=1.4.1
+
+# Documentation
+mkdocs>=1.5.2
+mkdocs-material>=9.1.21

setup.py

@@ -0,0 +1,32 @@
+from setuptools import setup, find_packages
+
+with open("README.md", "r", encoding="utf-8") as fh:
+    long_description = fh.read()
+
+with open("requirements.txt", "r", encoding="utf-8") as fh:
+    requirements = [line.strip() for line in fh if line.strip() and not line.startswith('#')]
+
+setup(
+    name="diabetes-prediction",
+    version="0.1.0",
+    author="Your Name",
+    author_email="your.email@example.com",
+    description="A Streamlit web application for diabetes prediction",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
+    url="https://github.com/yourusername/diabetes-prediction",
+    packages=find_packages(where="src"),
+    package_dir={"": "src"},
+    install_requires=requirements,
+    python_requires=">=3.8",
+    classifiers=[
+        "Programming Language :: Python :: 3",
+        "License :: OSI Approved :: MIT License",
+        "Operating System :: OS Independent",
+    ],
+    entry_points={
+        "console_scripts": [
+            "diabetes-prediction=diabetes_prediction.app:main",
+        ],
+    },
+)

src/diabetes_prediction/__init__.py

@@ -0,0 +1,6 @@
+"""Diabetes Prediction Application.
+
+This package provides functionality for predicting diabetes risk based on patient data.
+"""
+
+__version__ = '0.1.0'

src/diabetes_prediction/app.py

@@ -0,0 +1,189 @@
+"""Streamlit application for diabetes prediction."""
+
+import logging
+import sys
+from pathlib import Path
+
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+import seaborn as sns
+import streamlit as st
+
+# Add the project root to the Python path
+project_root = Path(__file__).parent.parent.parent
+sys.path.append(str(project_root))
+
+from diabetes_prediction.config import (
+    DATA_PATH,
+    FEATURES,
+    LOGGING_CONFIG,
+    MODEL_PATH,
+    PREDICTION_THRESHOLD,
+    ZERO_FEATURES,
+)
+from diabetes_prediction.data import load_data, preprocess_data
+from diabetes_prediction.model import DiabetesPredictor
+from diabetes_prediction.utils.helpers import ensure_directory_exists, setup_logging
+
+# Configure logging
+setup_logging(LOGGING_CONFIG)
+logger = logging.getLogger(__name__)
+
+def setup_page():
+    """Set up the Streamlit page configuration."""
+    st.set_page_config(
+        page_title="Diabetes Prediction App",
+        page_icon="🩺",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Custom CSS for better styling
+    st.markdown("""
+    <style>
+    .main {
+        max-width: 1000px;
+        padding: 2rem;
+    }
+    .stButton>button {
+        background-color: #4CAF50;
+        color: white;
+        font-weight: bold;
+    }
+    .stButton>button:hover {
+        background-color: #45a049;
+    }
+    .stAlert {
+        padding: 1rem;
+        border-radius: 0.5rem;
+    }
+    </style>
+    """, unsafe_allow_html=True)
+
+def display_header():
+    """Display the application header."""
+    st.title("Diabetes Prediction App")
+    st.markdown("""
+    This application uses machine learning to predict the likelihood of diabetes based on patient data.
+    Enter the patient's information in the sidebar and click 'Predict' to see the results.
+    """)
+
+def get_user_input():
+    """Get input features from the user via the sidebar.
+    
+    Returns:
+        dict: Dictionary of user inputs
+    """
+    st.sidebar.header('Patient Information')
+    
+    # Input fields with validation
+    pregnancies = st.sidebar.slider('Pregnancies', 0, 17, 3)
+    glucose = st.sidebar.number_input('Glucose (mg/dL)', 0, 200, 120, 1)
+    blood_pressure = st.sidebar.number_input('Blood Pressure (mm Hg)', 0, 122, 72, 1)
+    skin_thickness = st.sidebar.number_input('Skin Thickness (mm)', 0, 99, 23, 1)
+    insulin = st.sidebar.number_input('Insulin (μU/ml)', 0, 846, 30, 1)
+    bmi = st.sidebar.number_input('BMI', 0.0, 67.1, 32.0, 0.1)
+    diabetes_pedigree = st.sidebar.number_input('Diabetes Pedigree Function', 0.0, 2.42, 0.37, 0.01)
+    age = st.sidebar.slider('Age (years)', 21, 81, 29)
+    
+    return {
+        'Pregnancies': pregnancies,
+        'Glucose': glucose,
+        'BloodPressure': blood_pressure,
+        'SkinThickness': skin_thickness,
+        'Insulin': insulin,
+        'BMI': bmi,
+        'DiabetesPedigreeFunction': diabetes_pedigree,
+        'Age': age
+    }
+
+def display_prediction(prediction_prob, threshold=0.5):
+    """Display the prediction result.
+    
+    Args:
+        prediction_prob (float): Probability of diabetes (0-1)
+        threshold (float): Decision threshold for classification
+    """
+    st.subheader("Prediction Result")
+    
+    # Display probability with a progress bar
+    prob_percent = prediction_prob * 100
+    st.metric("Diabetes Risk", f"{prob_percent:.1f}%")
+    st.progress(float(prediction_prob))
+    
+    # Display interpretation
+    if prediction_prob >= threshold:
+        st.error("High risk of diabetes. Please consult a healthcare professional.")
+    else:
+        st.success("Low risk of diabetes. Maintain a healthy lifestyle!")
+    
+    # Show threshold info
+    st.caption(f"*Threshold for high risk: {threshold*100:.0f}%")
+
+def display_data_insights(df):
+    """Display data visualizations and insights."""
+    st.subheader("Data Insights")
+    
+    # Show data summary
+    with st.expander("View Data Summary"):
+        st.write(df.describe())
+    
+    # Show correlation heatmap
+    st.write("### Feature Correlation")
+    fig, ax = plt.subplots(figsize=(10, 8))
+    sns.heatmap(df.corr(), annot=True, cmap='coolwarm', center=0, ax=ax)
+    st.pyplot(fig)
+
+def main():
+    """Main application function."""
+    # Set up the page
+    setup_page()
+    display_header()
+    
+    # Initialize the model
+    model = DiabetesPredictor(MODEL_PATH)
+    
+    # Load and preprocess data
+    try:
+        df = load_data(DATA_PATH)
+        X, y = preprocess_data(df)
+        
+        # Display data insights in a tab
+        with st.expander("View Data Insights", expanded=False):
+            display_data_insights(df)
+        
+        # Get user input
+        user_data = get_user_input()
+        
+        # Convert user input to DataFrame
+        input_df = pd.DataFrame([user_data])
+        
+        # Make prediction when button is clicked
+        if st.sidebar.button('Predict', type='primary'):
+            with st.spinner('Making prediction...'):
+                # Train or load model
+                if not model.load_model():
+                    st.info("Training a new model...")
+                    X_train, X_test, y_train, y_test = split_data(X, y)
+                    model.train(X_train, y_train)
+                    model.save_model()
+                    
+                    # Show model performance
+                    st.success("Model trained successfully!")
+                    eval_metrics = model.evaluate(X_test, y_test)
+                    st.metric("Model Accuracy", f"{eval_metrics['accuracy']*100:.1f}%")
+                
+                # Make prediction
+                prediction_prob = model.predict(input_df)[0]
+                
+                # Display results
+                st.balloons()
+                display_prediction(prediction_prob)
+    
+    except Exception as e:
+        st.error(f"An error occurred: {str(e)}")
+        logger.exception("Error in main application")
+
+if __name__ == "__main__":
+    main()

src/diabetes_prediction/config.py

@@ -0,0 +1,82 @@
+"""Configuration settings for the diabetes prediction application."""
+
+from pathlib import Path
+
+# Base directory
+BASE_DIR = Path(__file__).parent.parent.parent
+
+# Data paths
+DATA_DIR = BASE_DIR / 'data'
+DATA_FILE = 'diabetes.csv'
+DATA_PATH = DATA_DIR / DATA_FILE
+
+# Model paths
+MODEL_DIR = BASE_DIR / 'models'
+MODEL_FILE = 'diabetes_model.joblib'
+MODEL_PATH = MODEL_DIR / MODEL_FILE
+
+# Model parameters
+MODEL_PARAMS = {
+    'n_estimators': 100,
+    'learning_rate': 0.1,
+    'max_depth': 3,
+    'random_state': 42
+}
+
+# Feature names
+FEATURES = [
+    'Pregnancies',
+    'Glucose',
+    'BloodPressure',
+    'SkinThickness',
+    'Insulin',
+    'BMI',
+    'DiabetesPedigreeFunction',
+    'Age'
+]
+
+# Target column
+TARGET = 'Outcome'
+
+# Data preprocessing
+ZERO_FEATURES = [
+    'Glucose',
+    'BloodPressure',
+    'SkinThickness',
+    'Insulin',
+    'BMI'
+]
+
+# Prediction threshold
+PREDICTION_THRESHOLD = 0.5
+
+# Logging configuration
+LOGGING_CONFIG = {
+    'version': 1,
+    'disable_existing_loggers': False,
+    'formatters': {
+        'standard': {
+            'format': '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+        },
+    },
+    'handlers': {
+        'default': {
+            'level': 'INFO',
+            'formatter': 'standard',
+            'class': 'logging.StreamHandler',
+            'stream': 'ext://sys.stdout',
+        },
+    },
+    'loggers': {
+        '': {  # root logger
+            'handlers': ['default'],
+            'level': 'INFO',
+            'propagate': False
+        },
+        'diabetes_prediction': {
+            'handlers': ['default'],
+            'level': 'DEBUG',
+            'propagate': False
+        },
+    }
+}

src/diabetes_prediction/data.py

@@ -0,0 +1,81 @@
+"""Data loading and preprocessing utilities for the diabetes prediction model."""
+
+import logging
+from pathlib import Path
+import pandas as pd
+import numpy as np
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import StandardScaler
+
+logger = logging.getLogger(__name__)
+
+def load_data(filepath='diabetes.csv'):
+    """Load and return the diabetes dataset.
+    
+    Args:
+        filepath (str): Path to the diabetes CSV file.
+        
+    Returns:
+        pd.DataFrame: Loaded diabetes dataset.
+    """
+    try:
+        # Try to load the CSV file
+        df = pd.read_csv(filepath)
+        logger.info(f"Successfully loaded data from {filepath}")
+        return df
+    except FileNotFoundError:
+        logger.error(f"Data file not found at {filepath}")
+        raise
+
+def preprocess_data(df):
+    """Preprocess the input DataFrame.
+    
+    Args:
+        df (pd.DataFrame): Input DataFrame with diabetes data.
+        
+    Returns:
+        tuple: (X, y) - Features and target variable
+    """
+    # Replace zeros with mean values for specific columns
+    df = df.copy()
+    
+    # Columns where zero values should be replaced with mean
+    zero_columns = ['Glucose', 'BloodPressure', 'SkinThickness', 'Insulin', 'BMI']
+    
+    for col in zero_columns:
+        df[col] = df[col].replace(0, np.nan)
+        mean_value = df[col].mean()
+        df[col] = df[col].fillna(mean_value)
+    
+    # Separate features and target
+    X = df.drop('Outcome', axis=1)
+    y = df['Outcome']
+    
+    return X, y
+
+def split_data(X, y, test_size=0.2, random_state=42):
+    """Split data into training and testing sets.
+    
+    Args:
+        X (pd.DataFrame): Features
+        y (pd.Series): Target variable
+        test_size (float): Proportion of the dataset to include in the test split
+        random_state (int): Random seed for reproducibility
+        
+    Returns:
+        tuple: X_train, X_test, y_train, y_test
+    """
+    return train_test_split(X, y, test_size=test_size, random_state=random_state, stratify=y)
+
+def get_scaler(X_train):
+    """Fit and return a StandardScaler on the training data.
+    
+    Args:
+        X_train (pd.DataFrame): Training features
+        
+    Returns:
+        StandardScaler: Fitted scaler
+    """
+    scaler = StandardScaler()
+    scaler.fit(X_train)
+    return scaler

src/diabetes_prediction/model.py

@@ -0,0 +1,123 @@
+"""Model training and evaluation for diabetes prediction."""
+
+import logging
+import joblib
+from pathlib import Path
+from sklearn.ensemble import GradientBoostingClassifier
+from sklearn.pipeline import Pipeline
+from sklearn.metrics import (
+    accuracy_score, 
+    classification_report, 
+    confusion_matrix, 
+    f1_score
+)
+
+logger = logging.getLogger(__name__)
+
+class DiabetesPredictor:
+    """A class to handle diabetes prediction model training and evaluation."""
+    
+    def __init__(self, model_path='models/model.joblib'):
+        """Initialize the DiabetesPredictor.
+        
+        Args:
+            model_path (str): Path to save/load the model
+        """
+        self.model_path = Path(model_path)
+        self.model = None
+        self.scaler = None
+    
+    def create_model(self, random_state=42):
+        """Create a new Gradient Boosting model.
+        
+        Args:
+            random_state (int): Random seed for reproducibility
+            
+        Returns:
+            Pipeline: A scikit-learn pipeline with preprocessing and model
+        """
+        return GradientBoostingClassifier(
+            n_estimators=100,
+            learning_rate=0.1,
+            max_depth=3,
+            random_state=random_state
+        )
+    
+    def train(self, X_train, y_train):
+        """Train the model on the given data.
+        
+        Args:
+            X_train (pd.DataFrame): Training features
+            y_train (pd.Series): Training target
+            
+        Returns:
+            Pipeline: Trained model pipeline
+        """
+        self.model = self.create_model()
+        self.model.fit(X_train, y_train)
+        return self.model
+    
+    def evaluate(self, X_test, y_test):
+        """Evaluate the model on test data.
+        
+        Args:
+            X_test (pd.DataFrame): Test features
+            y_test (pd.Series): True labels
+            
+        Returns:
+            dict: Dictionary of evaluation metrics
+        """
+        if self.model is None:
+            raise ValueError("Model has not been trained yet.")
+            
+        y_pred = self.model.predict(X_test)
+        
+        return {
+            'accuracy': accuracy_score(y_test, y_pred),
+            'f1': f1_score(y_test, y_pred, average='weighted'),
+            'classification_report': classification_report(y_test, y_pred, output_dict=True),
+            'confusion_matrix': confusion_matrix(y_test, y_pred).tolist()
+        }
+    
+    def predict(self, X):
+        """Make predictions on new data.
+        
+        Args:
+            X (pd.DataFrame): Input features
+            
+        Returns:
+            np.array: Predicted probabilities for class 1 (diabetes)
+        """
+        if self.model is None:
+            raise ValueError("Model has not been trained or loaded.")
+            
+        return self.model.predict_proba(X)[:, 1]
+    
+    def save_model(self):
+        """Save the model to disk."""
+        if self.model is None:
+            raise ValueError("No model to save.")
+            
+        # Create parent directories if they don't exist
+        self.model_path.parent.mkdir(parents=True, exist_ok=True)
+        
+        joblib.dump(self.model, self.model_path)
+        logger.info(f"Model saved to {self.model_path}")
+    
+    def load_model(self):
+        """Load a previously saved model from disk.
+        
+        Returns:
+            bool: True if model was loaded successfully, False otherwise
+        """
+        if not self.model_path.exists():
+            logger.warning(f"No saved model found at {self.model_path}")
+            return False
+            
+        try:
+            self.model = joblib.load(self.model_path)
+            logger.info(f"Model loaded from {self.model_path}")
+            return True
+        except Exception as e:
+            logger.error(f"Error loading model: {e}")
+            return False

src/diabetes_prediction/tests/test_data.py

@@ -0,0 +1,82 @@
+"""Tests for data processing functions."""
+
+import pytest
+import pandas as pd
+import numpy as np
+from pathlib import Path
+
+# Add the project root to the Python path
+import sys
+sys.path.append(str(Path(__file__).parent.parent))
+
+from src.diabetes_prediction.data import load_data, preprocess_data, split_data
+
+
+def test_load_data(tmp_path):
+    """Test loading data from a CSV file."""
+    # Create a temporary CSV file
+    data = {
+        'Pregnancies': [6, 1, 8],
+        'Glucose': [148, 85, 183],
+        'BloodPressure': [72, 66, 64],
+        'SkinThickness': [35, 29, 0],
+        'Insulin': [0, 0, 0],
+        'BMI': [33.6, 26.6, 23.3],
+        'DiabetesPedigreeFunction': [0.627, 0.351, 0.672],
+        'Age': [50, 31, 32],
+        'Outcome': [1, 0, 1]
+    }
+    test_file = tmp_path / "test_data.csv"
+    df = pd.DataFrame(data)
+    df.to_csv(test_file, index=False)
+    
+    # Test loading the data
+    loaded_df = load_data(test_file)
+    assert isinstance(loaded_df, pd.DataFrame)
+    assert loaded_df.shape == (3, 9)
+
+
+def test_preprocess_data():
+    """Test data preprocessing function."""
+    # Create test data with zeros that should be replaced
+    data = {
+        'Glucose': [0, 85, 0],
+        'BloodPressure': [72, 0, 64],
+        'SkinThickness': [35, 29, 0],
+        'Insulin': [0, 0, 0],
+        'BMI': [33.6, 26.6, 23.3],
+        'Outcome': [1, 0, 1]
+    }
+    df = pd.DataFrame(data)
+    
+    # Test preprocessing
+    X, y = preprocess_data(df)
+    
+    # Check that zeros were replaced with means
+    assert (X['Glucose'] != 0).all()
+    assert (X['BloodPressure'] != 0).all()
+    assert (X['SkinThickness'] != 0).all()
+    
+    # Check shapes
+    assert X.shape == (3, 5)  # 5 features
+    assert y.shape == (3,)    # 1 target
+
+
+def test_split_data():
+    """Test train-test splitting function."""
+    # Create test data
+    X = pd.DataFrame({'feature1': range(100), 'feature2': range(100, 200)})
+    y = pd.Series([0] * 50 + [1] * 50)  # Balanced classes
+    
+    # Test splitting
+    X_train, X_test, y_train, y_test = split_data(X, y, test_size=0.2, random_state=42)
+    
+    # Check shapes
+    assert len(X_train) == 80
+    assert len(X_test) == 20
+    assert len(y_train) == 80
+    assert len(y_test) == 20
+    
+    # Check stratification (approximately equal class distribution)
+    assert 0.4 <= y_train.mean() <= 0.6
+    assert 0.4 <= y_test.mean() <= 0.6

src/diabetes_prediction/utils/__init__.py

@@ -0,0 +1,3 @@
+"""Utility functions for the diabetes prediction application."""
+
+# This file makes the utils directory a Python package

src/diabetes_prediction/utils/helpers.py

@@ -0,0 +1,100 @@
+"""Helper functions for the diabetes prediction application."""
+
+import logging
+import logging.config
+import os
+import sys
+from pathlib import Path
+from typing import Any, Dict, Optional, Union
+
+
+def setup_logging(config: Optional[Dict[str, Any]] = None) -> None:
+    """Set up logging configuration.
+    
+    Args:
+        config: Optional logging configuration dictionary. If not provided,
+               uses a basic console configuration.
+    """
+    if config:
+        logging.config.dictConfig(config)
+    else:
+        logging.basicConfig(
+            level=logging.INFO,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            handlers=[logging.StreamHandler(sys.stdout)]
+        )
+    logger = logging.getLogger(__name__)
+    logger.debug("Logging configuration complete")
+
+
+def ensure_directory_exists(directory: Union[str, Path]) -> Path:
+    """Ensure that a directory exists, create it if it doesn't.
+    
+    Args:
+        directory: Directory path to check/create
+        
+    Returns:
+        Path object of the directory
+        
+    Raises:
+        OSError: If directory creation fails
+    """
+    path = Path(directory).resolve()
+    try:
+        path.mkdir(parents=True, exist_ok=True)
+        return path
+    except OSError as e:
+        logger = logging.getLogger(__name__)
+        logger.error(f"Failed to create directory {path}: {e}")
+        raise
+
+
+def get_absolute_path(relative_path: Union[str, Path]) -> Path:
+    """Convert a relative path to an absolute path based on the project root.
+    
+    Args:
+        relative_path: Path relative to the project root
+        
+    Returns:
+        Absolute path
+    """
+    project_root = Path(__file__).parent.parent.parent
+    return (project_root / relative_path).resolve()
+
+
+def load_environment_vars(env_file: Union[str, Path] = '.env') -> None:
+    """Load environment variables from a .env file.
+    
+    Args:
+        env_file: Path to the .env file
+    """
+    from dotenv import load_dotenv
+    
+    env_path = get_absolute_path(env_file)
+    if env_path.exists():
+        load_dotenv(dotenv_path=env_path, override=True)
+        logger = logging.getLogger(__name__)
+        logger.debug(f"Loaded environment variables from {env_path}")
+    else:
+        logger = logging.getLogger(__name__)
+        logger.warning(f"No .env file found at {env_path}")
+
+
+def validate_environment() -> bool:
+    """Validate that all required environment variables are set.
+    
+    Returns:
+        bool: True if all required environment variables are set, False otherwise
+    """
+    required_vars = [
+        # Add any required environment variables here
+    ]
+    
+    missing_vars = [var for var in required_vars if not os.getenv(var)]
+    
+    if missing_vars:
+        logger = logging.getLogger(__name__)
+        logger.error(f"Missing required environment variables: {', '.join(missing_vars)}")
+        return False
+        
+    return True

src/streamlit_app.py

@@ -1,40 +0,0 @@
-import altair as alt
-import numpy as np
-import pandas as pd
-import streamlit as st
-
-"""
-# Welcome to Streamlit!
-
-Edit `/streamlit_app.py` to customize this app to your heart's desire :heart:.
-If you have any questions, checkout our [documentation](https://docs.streamlit.io) and [community
-forums](https://discuss.streamlit.io).
-
-In the meantime, below is an example of what you can do with just a few lines of code:
-"""
-
-num_points = st.slider("Number of points in spiral", 1, 10000, 1100)
-num_turns = st.slider("Number of turns in spiral", 1, 300, 31)
-
-indices = np.linspace(0, 1, num_points)
-theta = 2 * np.pi * num_turns * indices
-radius = indices
-
-x = radius * np.cos(theta)
-y = radius * np.sin(theta)
-
-df = pd.DataFrame({
-    "x": x,
-    "y": y,
-    "idx": indices,
-    "rand": np.random.randn(num_points),
-})
-
-st.altair_chart(alt.Chart(df, height=700, width=700)
-    .mark_point(filled=True)
-    .encode(
-        x=alt.X("x", axis=None),
-        y=alt.Y("y", axis=None),
-        color=alt.Color("idx", legend=None, scale=alt.Scale()),
-        size=alt.Size("rand", legend=None, scale=alt.Scale(range=[1, 150])),
-    ))