app.py

import streamlit as st
import pandas as pd
import seaborn as sns
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler, LabelEncoder
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import classification_report, accuracy_score
import nbformat as nbf
import io
import sqlite3
from io import StringIO
import os

# Constants
DB_PATH = "db/database.db"
TEMP_DIR = "temp/"

# Ensure directories exist
os.makedirs(os.path.dirname(DB_PATH), exist_ok=True)
os.makedirs(TEMP_DIR, exist_ok=True)

# Initialize SQLite database
def init_db():
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    cursor.execute("""

        CREATE TABLE IF NOT EXISTS datasets (

            id INTEGER PRIMARY KEY AUTOINCREMENT,

            name TEXT NOT NULL,

            content TEXT NOT NULL

        )

    """)
    conn.commit()
    conn.close()

# Save dataset to SQLite
def save_dataset_to_db(name, content):
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    cursor.execute("INSERT INTO datasets (name, content) VALUES (?, ?)", (name, content))
    conn.commit()
    conn.close()

# Fetch all datasets from SQLite
def get_datasets():
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    cursor.execute("SELECT id, name FROM datasets")
    datasets = cursor.fetchall()
    conn.close()
    return datasets

# Load dataset by ID
def load_dataset_from_db(dataset_id):
    conn = sqlite3.connect(DB_PATH)
    cursor = conn.cursor()
    cursor.execute("SELECT content FROM datasets WHERE id = ?", (dataset_id,))
    content = cursor.fetchone()
    conn.close()
    if content:
        return StringIO(content[0])
    return None

# Initialize database
init_db()

# Function to detect problem type
def detect_problem_type(df, target_column):
    if target_column not in df.columns:
        return "Error: Target column not found in the dataset."

    df_clean = df.dropna(subset=[target_column])
    unique_values = df_clean[target_column].nunique()
    if unique_values == 2:
        return "binary_classification"
    elif unique_values > 2:
        return "multiclass_classification"
    else:
        return "Error: Invalid target column (not enough unique values)."

# Function to generate notebook content
def generate_notebook_code(csv_path, target_column, problem_type):
    notebook = nbf.v4.new_notebook()
    code = f"""

import pandas as pd

import seaborn as sns

import matplotlib.pyplot as plt

from sklearn.model_selection import train_test_split

from sklearn.preprocessing import StandardScaler, LabelEncoder

from sklearn.ensemble import RandomForestClassifier

from sklearn.metrics import classification_report, accuracy_score



# Load Dataset

df = pd.read_csv("{csv_path}")

target_column = "{target_column}"



# Display the first few rows

print(df.head())



# Check for missing values

print("Missing Values:\\n", df.isnull().sum())



# Encode categorical columns

categorical_cols = df.select_dtypes(include=['object']).columns

for col in categorical_cols:

    df[col] = LabelEncoder().fit_transform(df[col])



# Fill missing values with median

df.fillna(df.median(), inplace=True)



# Split data into features and target

X = df.drop(columns=[target_column])

y = df[target_column]



# Standardize numeric columns

scaler = StandardScaler()

X = scaler.fit_transform(X)



# Train/Test Split

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)



# Train Model

model = RandomForestClassifier() if "{problem_type}" in ["binary_classification", "multiclass_classification"] else None

model.fit(X_train, y_train)



# Predict and Evaluate

y_pred = model.predict(X_test)

print("Accuracy Score:", accuracy_score(y_test, y_pred))

print("Classification Report:\\n", classification_report(y_test, y_pred))

    """
    notebook.cells.append(nbf.v4.new_code_cell(code))
    return notebook

# Streamlit app
st.title("Automated Data Science App")
st.write("Upload a CSV file and specify the target column to automatically process and train models.")

# File upload
uploaded_file = st.file_uploader("Upload your CSV file", type="csv")
target_column = st.text_input("Enter the target column name")

if uploaded_file and target_column:
    try:
        df = pd.read_csv(uploaded_file)
        st.write("Dataset Preview:")
        st.write(df.head())

        st.subheader("Missing Values")
        st.write(df.isnull().sum())

        st.subheader("Basic Statistics")
        st.write(df.describe())

        problem_type = detect_problem_type(df, target_column)
        if "Error" in problem_type:
            st.error(problem_type)
        else:
            st.write(f"Detected Problem Type: {problem_type}")

            # Save dataset to database
            save_dataset_to_db(uploaded_file.name, uploaded_file.getvalue().decode("utf-8"))

            categorical_cols = df.select_dtypes(include=['object']).columns
            for col in categorical_cols:
                df[col] = LabelEncoder().fit_transform(df[col])

            df.fillna(df.median(), inplace=True)
            X = df.drop(columns=[target_column])
            y = df[target_column]

            scaler = StandardScaler()
            X = scaler.fit_transform(X)

            X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

            model = RandomForestClassifier()
            model.fit(X_train, y_train)

          # Evaluate model
            y_pred = model.predict(X_test)
            st.subheader("Model Performance")
            st.write("Accuracy:", accuracy_score(y_test, y_pred))

            # Display the classification report with proper formatting
            st.write("Classification Report:")
            report = classification_report(y_test, y_pred)
            st.code(report)  # st.text ensures the report is displayed with proper formatting

            feature_importances = model.feature_importances_
            important_features = pd.Series(feature_importances, index=df.drop(columns=[target_column]).columns)
            important_features = important_features.sort_values(ascending=False).head(5)

            st.subheader("Important Features")
            st.write(important_features)

            st.subheader("Visualizations")
            for feature in important_features.index:
                st.write(f"Box Plot for {feature}")
                fig, ax = plt.subplots(figsize=(8, 6))
                sns.boxplot(x=y, y=df[feature], ax=ax)
                st.pyplot(fig)

                st.write(f"Histogram for {feature}")
                fig, ax = plt.subplots(figsize=(8, 6))
                sns.histplot(df[feature], kde=True, bins=30, ax=ax)
                st.pyplot(fig)

            temp_csv_path = os.path.join(TEMP_DIR, uploaded_file.name)
            with open(temp_csv_path, "w") as f:
                f.write(uploaded_file.getvalue().decode("utf-8"))

            notebook = generate_notebook_code(temp_csv_path, target_column, problem_type)
            notebook_buffer = io.StringIO()
            nbf.write(notebook, notebook_buffer)
            notebook_buffer.seek(0)
            notebook_content = notebook_buffer.getvalue()

            st.download_button(
                label="Download Code Notebook",
                data=notebook_content,
                file_name="data_science_pipeline.ipynb",
                mime="application/json"
            )

    except Exception as e:
        st.error(f"An error occurred: {e}")