Initial commit

app.py

@@ -0,0 +1,257 @@
+#==============================================================
+#            Deendencies
+#===============================================================
+
+import gradio as gr
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
+import io
+import numpy as np
+import tempfile
+import os
+
+
+#==================================================================
+#        Other Dependencies
+#==================================================================
+
+from helper_functions import file_summary, load_csv
+from helper_functions import check_duplicate_columns, remove_duplicate_columns, check_duplicate_rows, remove_duplicate_rows, check_missing_columns, drop_high_missing, delete_column
+from helper_functions import get_missing_columns, detect_column_type, apply_missing_value
+from helper_functions import show_value_counts, encode_column
+from helper_functions import normalize_column_names, rename_single_column
+from helper_functions import get_numeric_columns, show_current_dtype, change_column_dtype
+from helper_functions import get_continuous_columns, show_column_stats, handle_outliers
+from helper_functions import make_csv_download
+
+from report_generation import generate_profile_report
+
+
+
+# ===========================================================
+#                     Gradio Layout
+# ===========================================================
+
+with gr.Blocks(theme="soft") as demo:
+    gr.Markdown("# <div align = 'center'> **Clean Data Dashboard** </div>") 
+    gr.Markdown("<div align = 'center'>In every machine learning workflow, data cleaning is one of the most time-consuming and repetitive tasks. yet, as ML engineers, our true focus should be on building models, crafting architectures, and solving real problems - not spending endless hours handling missing values, formatting inconsistencies and unwanted noise in CSV files.</div>") 
+    gr.Markdown("<div align = 'center'> That's exactly why I build this CSV Data Cleaning App. This tool helps you clean your data in few steps. All you need to do is to click on the button the operation you want to apply on the file. After applying all the operations, you can download the final cleaned CSV File.</div>")
+    gr.Markdown("---")
+
+    with gr.Row():
+        with gr.Column(scale=1, min_width=400):
+            gr.HTML("<div style='max-height: 90vh; overflow-y: auto; padding-right: 10px;'>")
+        
+            gr.Markdown("# ⚙️ Tools Panel")
+            
+            file_input = gr.File(label="Choose CSV", file_types=[".csv"])
+            load_btn = gr.Button("📂 Load CSV")
+            status_box = gr.Textbox(label="Status", interactive=False)
+            gr.Markdown("---")
+
+            delete_col = gr.Dropdown(label="Select Column to Delete")
+            gr.Markdown("Delete Columns which you don't need!")
+            delete_btn = gr.Button("🗑️ Delete Column")
+            delete_status = gr.Textbox(label="Delete Status", interactive=True)
+            gr.Markdown("---")
+
+            dup_col_status = gr.Textbox(label="Duplicate Columns", interactive=False)
+            dup_col_check = gr.Button("🔍 Check Duplicate Columns")
+            dup_col_btn = gr.Button("🧬 Remove Duplicate Columns")
+            gr.Markdown("---")
+
+            dup_row_status = gr.Textbox(label="Duplicate Rows", interactive=False)
+            dup_row_check = gr.Button("🔍 Check Duplicate Rows")
+            dup_row_btn = gr.Button("📄 Remove Duplicate Rows")
+            gr.Markdown("---")
+
+            missing_status = gr.Textbox(label="Missing Columns Check", interactive=False)
+            check_missing_btn = gr.Button("🔍 Check Columns with Missing Values")
+            drop_high_missing_btn = gr.Button("🧮 Drop Columns with >50% Missing Values")
+            gr.Markdown("---")
+
+            gr.Markdown("### 🧩 Handle Missing Values")
+            missing_col = gr.Dropdown(label="Select Column with Missing Values")
+            detect_type_box = gr.Textbox(label="Column Type", interactive=False)
+            fill_method = gr.Dropdown(label="Select Fill Method", choices=[])
+            apply_fill_btn = gr.Button("✨ Apply Fill Method")
+            fill_status = gr.Textbox(label="Fill Operation Status", interactive=False)
+            gr.Markdown("---")
+
+            gr.Markdown("### 🔤 Encoding Section")
+            encode_col = gr.Dropdown(label="Select Column to Encode")
+            encode_method = gr.Radio(["Label Encoding", "Ordinal Encoding"], label="Encoding Type", value="Label Encoding")
+            value_counts_box = gr.Textbox(label="Value Counts (for Ordinal Encoding)", interactive=False, lines=8)
+            encode_order = gr.Textbox(label="If Ordinal, Enter Order (comma-separated)")
+            encode_status = gr.Textbox(label="Encoding Status", interactive=False)
+            encode_btn = gr.Button("⚙️ Apply Encoding")
+            gr.Markdown("---")
+
+            gr.Markdown("### 🏷️ Column Name Normalization & Renaming")
+            normalize_btn = gr.Button("🔡 Normalize Column Names")
+            normalize_status = gr.Textbox(label="Normalization Status", interactive=False)
+            rename_col = gr.Dropdown(label="Select Column to Rename")
+            new_col_name = gr.Textbox(label="Enter New Column Name")
+            rename_btn = gr.Button("✏️ Rename Column")
+            rename_status = gr.Textbox(label="Rename Status", interactive=False)
+
+            gr.Markdown("---")
+            gr.Markdown("### 🔢 Change Data Type of Columns")
+            numeric_detect_btn = gr.Button("🔍 Detect Numeric Columns")
+            numeric_detect_status = gr.Textbox(label="Numeric Column Detection", interactive=False)
+            dtype_col = gr.Dropdown(label="Select Numeric Column")
+            current_dtype_box = gr.Textbox(label="Current Data Type", interactive=False)
+
+            # Target dtype selection
+            dtype_choices = [
+                "int8", "int16", "int32", "int64",
+                "float16", "float32", "float64",
+                "complex64", "complex128"
+            ]
+            new_dtype = gr.Dropdown(label="Select New Data Type", choices=dtype_choices)
+            convert_dtype_btn = gr.Button("🔁 Convert Data Type")
+            convert_dtype_status = gr.Textbox(label="Data Type Conversion Status", interactive=False)
+            gr.Markdown("---")
+
+            gr.Markdown("### 🚨 Outlier Detection & Handling")
+            detect_cont_col_btn = gr.Button("🔍 Detect Continuous Columns")
+            cont_col_status = gr.Textbox(label="Continuous Columns Detection", interactive=False)
+            outlier_col = gr.Dropdown(label="Select Continuous Column")
+            col_stats_box = gr.Textbox(label="Column Statistics", interactive=False)
+
+            # Technique + threshold
+            outlier_method = gr.Radio(
+                ["IQR", "Z-score", "Winsorization", "MinMax"],
+                label="Select Outlier Handling Technique",
+                value="IQR"
+            )
+            threshold_value = gr.Textbox(label="Enter Threshold Value (e.g., 1.5 for IQR, 3 for Z-score, etc.)")
+
+            # Apply technique
+            apply_outlier_btn = gr.Button("🧮 Apply Technique")
+            outlier_status = gr.Textbox(label="Outlier Handling Status", interactive=False)
+
+            gr.Markdown("---")
+            reset_btn = gr.Button("♻️ Reset to Original")
+            download_trigger = gr.Button("📥 Generate & Download Cleaned CSV")
+            download_file = gr.File(label="Your Cleaned CSV File Will Appear Below 👇")
+            gr.HTML("</div>")
+
+
+        with gr.Column(scale=3):
+            gr.Markdown("# Data Panel")
+            summary_table = gr.DataFrame(label="📊 File Summary", interactive=True, wrap=True)
+            gr.Markdown("---")
+            gr.Markdown("## 🧾 Data Preview")
+            original_df = gr.DataFrame(label="📘 Original Dataset", wrap=True, interactive=False)
+            working_df = gr.DataFrame(label="🧪 Working Dataset", wrap=True)
+
+    gr.Markdown("---")
+    gr.Markdown("### 🧾 Generate Detailed Data Report")
+
+    generate_report_btn = gr.Button("📈 Create Data Report (It might take time)")
+    report_status = gr.HTML(label="Report Status")
+    report_file = gr.File(label="Download or View Report")
+
+
+    # ===========================================================
+    #                    Event Bindings
+    # ===========================================================
+
+    load_btn.click(load_csv,
+        inputs=file_input,
+        outputs=[original_df, working_df, summary_table, delete_col, encode_col, status_box]
+    )
+
+    delete_btn.click(delete_column, inputs=[working_df, delete_col], outputs=[working_df, delete_status])
+    dup_col_check.click(check_duplicate_columns, inputs=working_df, outputs=dup_col_status)
+    dup_col_btn.click(remove_duplicate_columns, inputs=working_df, outputs=[working_df, dup_col_status])
+    dup_row_check.click(check_duplicate_rows, inputs=working_df, outputs=dup_row_status)
+    dup_row_btn.click(remove_duplicate_rows, inputs=working_df, outputs=[working_df, dup_row_status])
+    check_missing_btn.click(check_missing_columns, inputs=working_df, outputs=missing_status)
+    drop_high_missing_btn.click(drop_high_missing, inputs=working_df, outputs=[working_df, missing_status])
+
+    # Missing values section
+    check_missing_btn.click(get_missing_columns, inputs=working_df, outputs=[missing_col, missing_status])
+    missing_col.change(detect_column_type, inputs=[working_df, missing_col], outputs=[detect_type_box, fill_method])
+    apply_fill_btn.click(apply_missing_value, inputs=[working_df, missing_col, fill_method], outputs=[working_df, fill_status])
+
+    # Encoding section
+    encode_col.change(show_value_counts, inputs=[working_df, encode_col, encode_method], outputs=value_counts_box)
+    encode_method.change(show_value_counts, inputs=[working_df, encode_col, encode_method], outputs=value_counts_box)
+    encode_btn.click(
+        lambda df, col, method, order_str: encode_column(df, col, method, [x.strip() for x in order_str.split(",")] if order_str else None),
+        inputs=[working_df, encode_col, encode_method, encode_order],
+        outputs=[working_df, encode_status]
+    )
+
+
+   # Normalize column names
+    def normalize_and_update(df):
+        df, msg = normalize_column_names(df)
+        if df is None:
+            return df, gr.update(choices=[]), gr.update(choices=[]), gr.update(choices=[]), msg
+        cols = df.columns.tolist()
+        return df, gr.update(choices=cols), gr.update(choices=cols), gr.update(choices=cols), msg
+
+    normalize_btn.click(
+        normalize_and_update,
+        inputs=working_df,
+        outputs=[working_df, delete_col, rename_col, encode_col, normalize_status]
+    )
+
+    # rename columns
+    def rename_and_update(df, old_col, new_col):
+        df, msg = rename_single_column(df, old_col, new_col)
+        if df is None:
+            return df, gr.update(choices=[]), gr.update(choices=[]), gr.update(choices=[]), msg
+        cols = df.columns.tolist()
+        return df, gr.update(choices=cols), gr.update(choices=cols), gr.update(choices=cols), msg
+
+    rename_btn.click(
+        rename_and_update,
+        inputs=[working_df, rename_col, new_col_name],
+        outputs=[working_df, delete_col, rename_col, encode_col, rename_status]
+    )
+
+    # ====================== Data Type Change Section ======================
+
+    # Detect numeric columns
+    numeric_detect_btn.click(get_numeric_columns, inputs=working_df, outputs=[dtype_col, numeric_detect_status])
+
+    # Show current dtype when a column is selected
+    dtype_col.change(show_current_dtype, inputs=[working_df, dtype_col], outputs=current_dtype_box)
+
+    # Apply dtype change
+    convert_dtype_btn.click(change_column_dtype, inputs=[working_df, dtype_col, new_dtype], outputs=[working_df, convert_dtype_status])
+
+    # ===================== Outlier Detection Section =====================
+
+    # Detect continuous columns
+    detect_cont_col_btn.click(get_continuous_columns, inputs=working_df, outputs=[outlier_col, cont_col_status])
+
+    # Show stats when a column is selected
+    outlier_col.change(show_column_stats, inputs=[working_df, outlier_col], outputs=col_stats_box)
+
+    # Apply selected outlier handling technique
+    apply_outlier_btn.click(
+        handle_outliers,
+        inputs=[working_df, outlier_col, outlier_method, threshold_value],
+        outputs=[working_df, outlier_status]
+    )
+
+
+    reset_btn.click(lambda df_orig: (df_orig.copy(), "✅ Reset to original dataset."),
+        inputs=original_df,
+        outputs=[working_df, status_box]
+    )
+
+    download_trigger.click(make_csv_download, inputs=working_df, outputs=download_file)
+
+    generate_report_btn.click(
+        generate_profile_report,
+        inputs=working_df,
+        outputs=[report_file, report_status]
+    )
+
+demo.launch()

helper_functions.py

@@ -0,0 +1,405 @@
+import gradio as gr
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
+import io
+import numpy as np
+import tempfile
+import os
+
+
+# ===========================================================
+#                     Helper Functions
+# ===========================================================
+
+def file_summary(df):
+    if df is None:
+        return pd.DataFrame(), "⚠️ No data loaded."
+    memory_usage = df.memory_usage(deep=True)
+    column_types = []
+    for col in df.columns:
+        dtype = df[col].dtype
+        if pd.api.types.is_numeric_dtype(dtype):
+            unique_ratio = df[col].nunique() / len(df) if len(df) > 0 else 0
+            if unique_ratio < 0.05 or df[col].nunique() < 20:
+                column_types.append("Categorical (Numerical)")
+            else:
+                column_types.append("Continuous")
+        elif pd.api.types.is_object_dtype(dtype) or pd.api.types.is_categorical_dtype(dtype):
+            column_types.append("Categorical (String/Object)")
+        elif pd.api.types.is_bool_dtype(dtype):
+            column_types.append("Categorical (Boolean)")
+        else:
+            column_types.append("Other")
+
+    mem_vals = [round(df[c].memory_usage(deep=True) / 1024, 2) for c in df.columns]
+    summary_df = pd.DataFrame({
+        "Column": df.columns,
+        "Data Type": df.dtypes.values,
+        "Column Type": column_types,
+        "NULL Values": df.isnull().sum().values,
+        "Memory Size (KB)": mem_vals
+    })
+    return summary_df, f"📊 Summary Generated: {df.shape[1]} columns, {df.shape[0]} rows"
+
+
+# ===========================================================
+#                   Loading CSV + UI helpers
+# ===========================================================
+
+def load_csv(file):
+    if file is None:
+        return None, None, pd.DataFrame(), gr.update(choices=[]), gr.update(choices=[]), "⚠️ Please upload a CSV file."
+    try:
+        df = pd.read_csv(file.name)
+        cols = df.columns.tolist()
+        # Detect only encodable columns
+        encodable_cols = df.select_dtypes(include=["object", "category", "bool"]).columns.tolist()
+        summary, _ = file_summary(df)
+        return df, df.copy(), summary, gr.update(choices=cols), gr.update(choices=encodable_cols), f"✅ File loaded successfully! Shape: {df.shape}"
+    except Exception as e:
+        return None, None, pd.DataFrame(), gr.update(choices=[]), gr.update(choices=[]), f"❌ Error: {e}"
+
+
+# ===========================================================
+#                Duplicate, Missing & Deletion
+# ===========================================================
+
+def check_duplicate_columns(df):
+    if df is None:
+        return "⚠️ Please load a dataset first."
+    dup_cols = df.columns[df.columns.duplicated()]
+    if len(dup_cols) == 0:
+        return "✅ No duplicate columns found."
+    return f"⚠️ Found duplicate columns: {', '.join(dup_cols)}"
+
+def remove_duplicate_columns(df):
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    dup_cols = df.columns[df.columns.duplicated()]
+    if len(dup_cols) == 0:
+        return df, "✅ No duplicate columns to remove."
+    df = df.loc[:, ~df.columns.duplicated()]
+    return df, f"✅ Removed duplicate columns: {', '.join(dup_cols)}"
+
+def check_duplicate_rows(df):
+    if df is None:
+        return "⚠️ Please load a dataset first."
+    dup_rows = df.duplicated().sum()
+    if dup_rows == 0:
+        return "✅ No duplicate rows found."
+    return f"⚠️ Found {dup_rows} duplicate rows."
+
+def remove_duplicate_rows(df):
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    dup_rows = df.duplicated().sum()
+    if dup_rows == 0:
+        return df, "✅ No duplicate rows to remove."
+    df = df.drop_duplicates()
+    return df, f"✅ Removed {dup_rows} duplicate rows successfully."
+
+def check_missing_columns(df):
+    if df is None:
+        return "⚠️ Please load a dataset first."
+    missing = df.isnull().sum()
+    cols_with_missing = missing[missing > 0]
+    if cols_with_missing.empty:
+        return "✅ No missing values found."
+    return f"⚠️ Columns with missing values: {', '.join(cols_with_missing.index)}"
+
+def drop_high_missing(df):
+    if df is None:
+        return df, "⚠️ No data loaded."
+    missing_pct = df.isnull().mean() * 100
+    to_drop = missing_pct[missing_pct > 50].index.tolist()
+    if not to_drop:
+        return df, "✅ No columns with >50% missing values."
+    df = df.drop(columns=to_drop)
+    return df, f"✅ Dropped columns with >50% missing values: {', '.join(to_drop)}"
+
+def delete_column(df, col):
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    if col not in df.columns:
+        return df, f"⚠️ Column '{col}' not found."
+    df = df.drop(columns=[col])
+    return df, f"✅ Column '{col}' deleted."
+
+
+# ===========================================================
+#     Missing Value Handler (Column-Type Based Logic)
+# ===========================================================
+
+def get_missing_columns(df):
+    if df is None:
+        return gr.update(choices=[]), "⚠️ Please load a dataset first."
+    cols = df.columns[df.isnull().any()].tolist()
+    if not cols:
+        return gr.update(choices=[]), "✅ No columns with missing values."
+    return gr.update(choices=cols), f"⚠️ Columns with missing values: {', '.join(cols)}"
+
+def detect_column_type(df, column):
+    if df is None or column not in df.columns:
+        return "⚠️ Invalid column.", gr.update(choices=[])
+    dtype = df[column].dtype
+    if pd.api.types.is_numeric_dtype(dtype):
+        unique_ratio = df[column].nunique() / len(df)
+        if unique_ratio < 0.05 or df[column].nunique() < 20:
+            col_type = "Categorical (Numerical)"
+            options = ["Mode"]
+        else:
+            col_type = "Continuous (Numerical)"
+            options = ["Mean", "Median", "Mode"]
+    else:
+        col_type = "Categorical (String/Object)"
+        options = ["Mode"]
+    return f"🧩 Column Type: {col_type}", gr.update(choices=options, value=options[0])
+
+def apply_missing_value(df, column, method):
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    if column not in df.columns:
+        return df, f"⚠️ Column '{column}' not found."
+    if df[column].isnull().sum() == 0:
+        return df, f"✅ Column '{column}' has no missing values."
+
+    if pd.api.types.is_numeric_dtype(df[column]):
+        if method == "Mean":
+            df[column].fillna(df[column].mean(), inplace=True)
+        elif method == "Median":
+            df[column].fillna(df[column].median(), inplace=True)
+        elif method == "Mode":
+            df[column].fillna(df[column].mode().iloc[0], inplace=True)
+    else:
+        df[column].fillna(df[column].mode().iloc[0], inplace=True)
+    return df, f"✅ Missing values in '{column}' filled using {method}."
+
+
+# ===========================================================
+#               Encoding + Download Functions
+# ===========================================================
+
+def show_value_counts(df, col, method):
+    """Show value counts only if Ordinal Encoding is selected."""
+    if df is None or col not in df.columns:
+        return gr.DataFrame(value="⚠️ Please select a valid column.")
+    if method != "Ordinal Encoding":
+        return gr.DataFrame(value="ℹ️ Value counts visible only for Ordinal Encoding.")
+    counts = df[col].value_counts(dropna=False).reset_index()
+    counts.columns = [col, "Count"]
+    return counts
+
+def encode_column(df, col, method, order):
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    if col not in df.columns:
+        return df, "⚠️ Column not found."
+
+    if method == "Label Encoding":
+        le = LabelEncoder()
+        df[col] = le.fit_transform(df[col].astype(str))
+        return df, f"✅ Label Encoding applied on '{col}'."
+
+    elif method == "Ordinal Encoding":
+        if not order:
+            return df, "⚠️ Please provide order for Ordinal Encoding."
+
+        # Normalize both the column values and user-provided order for comparison
+        df[col] = df[col].astype(str).str.strip()
+        user_order = [x.strip() for x in order if x.strip()]
+        col_values = sorted(df[col].dropna().unique().tolist())
+
+        # Check if user provided valid categories
+        missing_from_col = [x for x in user_order if x not in col_values]
+        extra_in_col = [x for x in col_values if x not in user_order]
+
+        if missing_from_col:
+            return df, f"❌ Invalid category(s): {missing_from_col}. Please check spelling/case. Existing values: {col_values}"
+
+        if extra_in_col:
+            msg = f"⚠️ Warning: Some values in column were not in the provided order and will be encoded as NaN: {extra_in_col}"
+        else:
+            msg = ""
+
+        try:
+            oe = OrdinalEncoder(categories=[user_order])
+            df[col] = oe.fit_transform(df[[col]])
+            return df, f"✅ Ordinal Encoding applied on '{col}' with order {user_order}. {msg}"
+        except Exception as e:
+            return df, f"❌ Error during encoding: {e}"
+
+    return df, "⚠️ Invalid encoding method."
+
+
+
+# ===========================================================
+#         Column Normalization & Renaming Functions
+# ===========================================================
+
+def normalize_column_names(df):
+    """Convert all column names to lowercase, strip spaces, and replace internal spaces with underscores."""
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+
+    original_cols = df.columns.tolist()
+    new_cols = [col.strip().lower().replace(" ", "_") for col in original_cols]
+    rename_map = {old: new for old, new in zip(original_cols, new_cols) if old != new}
+    df.columns = new_cols
+
+    if not rename_map:
+        return df, "✅ All column names were already normalized."
+    return df, f"✅ Column names normalized: {rename_map}"
+
+
+def rename_single_column(df, old_col, new_col):
+    """Rename one specific column."""
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    if old_col not in df.columns:
+        return df, f"⚠️ Column '{old_col}' not found."
+    if not new_col.strip():
+        return df, "⚠️ Please enter a valid new column name."
+
+    df = df.rename(columns={old_col: new_col.strip()})
+    return df, f"✅ Column '{old_col}' renamed to '{new_col.strip()}'."
+
+
+# ===========================================================
+#            Data Type Conversion (Numerical Columns)
+# ===========================================================
+
+def get_numeric_columns(df):
+    """Return a list of numeric columns for dtype conversion."""
+    if df is None:
+        return gr.update(choices=[]), "⚠️ Please load a dataset first."
+    num_cols = df.select_dtypes(include=["int", "float", "complex"]).columns.tolist()
+    if not num_cols:
+        return gr.update(choices=[]), "✅ No numeric columns available for conversion."
+    return gr.update(choices=num_cols), f"🔢 Numeric columns available: {', '.join(num_cols)}"
+
+
+def show_current_dtype(df, col):
+    """Display the current dtype of the selected numeric column."""
+    if df is None or col not in df.columns:
+        return "⚠️ Please select a valid column."
+    dtype = str(df[col].dtype)
+    return f"📘 Current Data Type: {dtype}"
+
+
+def change_column_dtype(df, col, new_dtype):
+    """Change the data type of a numeric column using pandas .astype()."""
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    if col not in df.columns:
+        return df, f"⚠️ Column '{col}' not found."
+    if not new_dtype:
+        return df, "⚠️ Please select a new data type."
+
+    try:
+        df[col] = df[col].astype(new_dtype)
+        return df, f"✅ Column '{col}' converted to type '{new_dtype}'."
+    except Exception as e:
+        return df, f"❌ Conversion failed: {e}"
+
+
+
+# ===========================================================
+#            Outlier Detection & Handling Functions
+# ===========================================================
+
+
+def get_continuous_columns(df):
+    """Detect all numerical columns (int and float) for outlier handling."""
+    if df is None:
+        return gr.update(choices=[]), "⚠️ Please load a dataset first."
+    
+    numeric_cols = df.select_dtypes(include=["int", "float"]).columns.tolist()
+    
+    if not numeric_cols:
+        return gr.update(choices=[]), "✅ No numerical columns found."
+    
+    return gr.update(choices=numeric_cols), f"📊 Numerical columns detected: {', '.join(numeric_cols)}"
+
+
+
+def show_column_stats(df, col):
+    """Display basic stats for selected continuous column."""
+    if df is None or col not in df.columns:
+        return "⚠️ Please select a valid column."
+    stats = df[col].describe().to_dict()
+    return (
+        f"📈 Column: {col}\n"
+        f"Mean: {stats['mean']:.3f}, Std: {stats['std']:.3f}, Min: {stats['min']:.3f}, Max: {stats['max']:.3f}"
+    )
+
+
+def handle_outliers(df, col, method, threshold):
+    """Apply chosen outlier handling technique."""
+    if df is None:
+        return df, "⚠️ Please load a dataset first."
+    if col not in df.columns:
+        return df, f"⚠️ Column '{col}' not found."
+    if not pd.api.types.is_numeric_dtype(df[col]):
+        return df, f"⚠️ Column '{col}' is not numeric."
+    if threshold is None or str(threshold).strip() == "":
+        return df, "⚠️ Please enter a valid threshold value."
+
+    try:
+        threshold = float(threshold)
+    except:
+        return df, "⚠️ Threshold value must be numeric."
+
+    series = df[col]
+
+    # IQR method
+    if method == "IQR":
+        Q1, Q3 = series.quantile(0.25), series.quantile(0.75)
+        IQR = Q3 - Q1
+        lower = Q1 - threshold * IQR
+        upper = Q3 + threshold * IQR
+        before = series.copy()
+        df[col] = np.clip(series, lower, upper)
+        return df, f"✅ IQR method applied with threshold={threshold}. Clipped {sum(before != df[col])} outliers."
+
+    # Z-score method
+    elif method == "Z-score":
+        mean, std = series.mean(), series.std()
+        z_scores = (series - mean) / std
+        mask = np.abs(z_scores) > threshold
+        before = series.copy()
+        df.loc[mask, col] = mean  # replace with mean
+        return df, f"✅ Z-score method applied (|Z| > {threshold}). Replaced {mask.sum()} outliers with mean."
+
+    # Winsorization
+    elif method == "Winsorization":
+        lower = series.quantile(threshold / 100)
+        upper = series.quantile(1 - threshold / 100)
+        before = series.copy()
+        df[col] = np.clip(series, lower, upper)
+        return df, f"✅ Winsorization applied with {threshold}% tails capped."
+
+    # Min-Max clipping
+    elif method == "MinMax":
+        min_val = series.min()
+        max_val = series.max()
+        lower = min_val + threshold * (max_val - min_val)
+        upper = max_val - threshold * (max_val - min_val)
+        before = series.copy()
+        df[col] = np.clip(series, lower, upper)
+        return df, f"✅ Min-Max clipping applied with threshold={threshold}. Clipped {sum(before != df[col])} values."
+
+    else:
+        return df, "⚠️ Invalid outlier handling method selected."
+
+# ===========================================================
+#            Downloading the Cleaned CSV File
+# ===========================================================
+
+def make_csv_download(df):
+    if df is None or df.empty:
+        return None
+    # Create a temporary file
+    temp_dir = tempfile.gettempdir()
+    temp_path = os.path.join(temp_dir, "cleaned_data.csv")
+    df.to_csv(temp_path, index=False)
+    return temp_path

report_generation.py

@@ -0,0 +1,38 @@
+import gradio as gr
+import pandas as pd
+from sklearn.preprocessing import LabelEncoder, OrdinalEncoder
+import io
+import numpy as np
+import tempfile
+import os
+
+
+# ===========================================================
+#        Detailed Data Report using pandas-profiling
+# ===========================================================
+
+def generate_profile_report(df):
+    """Generate a pandas profiling HTML report and optionally open in a new tab."""
+    if df is None or df.empty:
+        return None, "⚠️ Please load a valid dataset first."
+
+    try:
+        from ydata_profiling import ProfileReport
+    except ImportError:
+        return None, "❌ Missing dependency: please install it using 'pip install ydata-profiling'."
+
+    try:
+        profile = ProfileReport(df, title="📊 Detailed Data Report", explorative=True)
+        output_path = "data_profile_report.html"
+        profile.to_file(output_path)
+
+        # Create a clickable HTML link that opens in new tab
+        html_link = f"""
+        ✅ Report generated successfully! Now Download the report (in HTML format) and open it.<br>
+        """
+        # Return the file + HTML message
+        return output_path, html_link
+    except Exception as e:
+        return None, f"❌ Failed to generate report: {e}"
+
+

requirements.txt

@@ -0,0 +1,15 @@
+# Core libraries
+pandas
+numpy
+gradio>=5.0.0
+
+# Machine Learning preprocessing tools
+scikit-learn
+
+# Optional but used for detailed data report generation
+ydata-profiling
+
+# Standard Python utilities (already included with Python, listed for clarity)
+io
+tempfile
+os