Initial deploy: ML Data Analysis Studio

README.md

@@ -1,13 +1,44 @@
 ---
-title: Ml Data Analysis Studio
-emoji: 🏆
-colorFrom: purple
-colorTo: green
+title: ML Data Analysis Studio
+emoji: 🤖
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 6.19.0
-python_version: '3.13'
+sdk_version: 4.44.0
 app_file: app.py
 pinned: false
+license: mit
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# 🤖 ML Data Analysis Studio
+
+An interactive machine-learning playground. Upload a dataset in almost any format, clean it, train models, inspect the generated code, and download full analysis reports.
+
+## Features
+
+- **💬 ML Assistant** — chat about ML models (random forests, SVM, overfitting, metrics, model selection...) and get guided through the analysis workflow.
+- **📊 Data upload & preprocessing** — supports CSV, TSV, Excel, JSON, and Parquet. Automatic profiling (missing values, duplicates, dtypes), then configurable cleaning: imputation or row-dropping, duplicate removal, one-hot encoding, and standard scaling. Cleaned data is cached temporarily and reused for modeling.
+- **🧠 Model training** — regression (Linear, Decision Tree, Random Forest, Gradient Boosting, SVR, KNN) and classification (Logistic, Decision Tree, Random Forest, Gradient Boosting, SVC, KNN). Auto-suggests the task type from your target column. Shows metrics, an actual-vs-predicted / confusion-matrix plot, and feature importance.
+- **👨‍💻 Code viewer** — dropdown accordions reveal the exact standalone Python (pandas + scikit-learn) equivalent to every preprocessing and training step, ready to copy.
+- **📥 Downloads** — one-click export of a PDF report, a self-contained HTML report, and the cleaned dataset as CSV.
+
+## Deploying to Hugging Face Spaces
+
+1. Create a new Space at https://huggingface.co/new-space → SDK: **Gradio**.
+2. Upload all files in this folder (`app.py`, `chat_engine.py`, `data_processor.py`, `ml_models.py`, `report_generator.py`, `requirements.txt`, `README.md`).
+3. The Space builds automatically and goes live in a few minutes.
+
+Or via git:
+
+```bash
+git clone https://huggingface.co/spaces/<your-username>/<space-name>
+cp -r ml-analysis-space/* <space-name>/
+cd <space-name> && git add . && git commit -m "Initial app" && git push
+```
+
+## Run locally
+
+```bash
+pip install -r requirements.txt
+python app.py
+```

app.py

@@ -0,0 +1,305 @@
+"""ML Data Analysis Studio — Gradio app for Hugging Face Spaces.
+
+Chat about ML models, upload data in any common format, preprocess it,
+train regression/classification models, inspect the generated code,
+and download PDF/HTML reports plus the cleaned dataset.
+"""
+
+import os
+import traceback
+
+import gradio as gr
+import pandas as pd
+
+import chat_engine
+import ml_models
+from data_processor import (
+    CLEANED_PATH,
+    generate_preprocessing_code,
+    load_data,
+    preprocess_data,
+    profile_data,
+    profile_text,
+)
+from report_generator import generate_html_report, generate_pdf_report
+
+# ---------------------------------------------------------------- state ----
+STATE = {
+    "raw_df": None,
+    "clean_df": None,
+    "file_name": None,
+    "profile": None,
+    "steps": [],
+    "result": None,
+}
+
+
+# ----------------------------------------------------------------- chat ----
+def chat_fn(message, history):
+    if not message.strip():
+        return ""
+    return chat_engine.respond(message, STATE["file_name"])
+
+
+# --------------------------------------------------------------- upload ----
+def upload_fn(file):
+    if file is None:
+        return "Upload a file to begin.", None, gr.update(choices=[]), ""
+    try:
+        df = load_data(file.name)
+    except Exception as e:
+        return f"❌ Could not read file: {e}", None, gr.update(choices=[]), ""
+    STATE["raw_df"] = df
+    STATE["file_name"] = os.path.basename(file.name)
+    STATE["profile"] = profile_data(df)
+    STATE["clean_df"] = None
+    STATE["result"] = None
+    msg = (
+        f"✅ Loaded **{STATE['file_name']}**. Do you want me to analyse this data? "
+        f"Review the profile below, adjust the cleaning options, and click "
+        f"**Run Preprocessing**.\n\n" + profile_text(STATE["profile"])
+    )
+    cols = df.columns.tolist()
+    return msg, df.head(20), gr.update(choices=cols, value=cols[-1]), ""
+
+
+# ----------------------------------------------------------- preprocess ----
+def preprocess_fn(missing_strategy, drop_dups, encode_cats, scale_num, target):
+    if STATE["raw_df"] is None:
+        return "⚠️ Upload a dataset first.", None, "", gr.update(choices=[])
+    try:
+        clean_df, steps = preprocess_data(
+            STATE["raw_df"],
+            missing_strategy=missing_strategy,
+            drop_duplicates=drop_dups,
+            encode_categoricals=encode_cats,
+            scale_numeric=scale_num,
+            target_column=target or None,
+        )
+    except Exception as e:
+        return f"❌ Preprocessing failed: {e}", None, "", gr.update(choices=[])
+    STATE["clean_df"] = clean_df
+    STATE["steps"] = steps
+    code = generate_preprocessing_code(
+        missing_strategy, drop_dups, encode_cats, scale_num, target or None
+    )
+    msg = "### ✅ Preprocessing complete\n\n" + "\n".join(f"- {s}" for s in steps)
+    cols = clean_df.columns.tolist()
+    default_target = target if target in cols else (cols[-1] if cols else None)
+    return msg, clean_df.head(20), code, gr.update(choices=cols, value=default_target)
+
+
+# ---------------------------------------------------------------- train ----
+def suggest_task_fn(target):
+    df = STATE["clean_df"] if STATE["clean_df"] is not None else STATE["raw_df"]
+    if df is None or not target or target not in df.columns:
+        return gr.update()
+    task = ml_models.suggest_task(df, target)
+    return gr.update(
+        value=task,
+        info=f"Suggested: {task} (based on the '{target}' column)",
+    )
+
+
+def task_models_fn(task):
+    models = (
+        list(ml_models.CLASSIFICATION_MODELS)
+        if task == "Classification"
+        else list(ml_models.REGRESSION_MODELS)
+    )
+    return gr.update(choices=models, value=models[0])
+
+
+def train_fn(target, task, model_name, test_size):
+    empty = (None,) * 4
+    if STATE["clean_df"] is None:
+        if STATE["raw_df"] is None:
+            return ("⚠️ Upload a dataset first (Data & Preprocessing tab).", *empty)
+        return ("⚠️ Run preprocessing first (Data & Preprocessing tab).", *empty)
+    if not target:
+        return ("⚠️ Select a target column.", *empty)
+    valid = (
+        ml_models.CLASSIFICATION_MODELS
+        if task == "Classification"
+        else ml_models.REGRESSION_MODELS
+    )
+    if model_name not in valid:
+        model_name = list(valid)[0]
+    try:
+        result = ml_models.train_model(
+            STATE["clean_df"], target, model_name, task, test_size
+        )
+    except Exception as e:
+        traceback.print_exc()
+        return (f"❌ Training failed: {e}", *empty)
+    STATE["result"] = result
+
+    metrics_md = "\n".join(f"| {k} | {v} |" for k, v in result["metrics"].items())
+    msg = (
+        f"### ✅ {model_name} trained\n\n"
+        f"**Task:** {task} | **Target:** `{target}` | "
+        f"**Train/test:** {result['n_train']:,}/{result['n_test']:,} | "
+        f"**Features used:** {len(result['features'])}\n\n"
+        f"| Metric | Value |\n|---|---|\n{metrics_md}"
+    )
+    code = ml_models.generate_model_code(model_name, task, target, test_size)
+    return (
+        msg,
+        result["plot_path"],
+        result["importance_path"],
+        code,
+        pd.DataFrame([result["metrics"]]),
+    )
+
+
+# ------------------------------------------------------------- download ----
+def download_fn(formats):
+    if STATE["result"] is None:
+        return "⚠️ Train a model first — the report includes its results.", []
+    files = []
+    try:
+        if "PDF report" in formats:
+            files.append(generate_pdf_report(STATE["profile"], STATE["steps"], STATE["result"]))
+        if "HTML report" in formats:
+            files.append(generate_html_report(STATE["profile"], STATE["steps"], STATE["result"]))
+        if "Cleaned data (CSV)" in formats and os.path.exists(CLEANED_PATH):
+            files.append(CLEANED_PATH)
+    except Exception as e:
+        traceback.print_exc()
+        return f"❌ Report generation failed: {e}", []
+    if not files:
+        return "⚠️ Select at least one format.", []
+    return f"✅ Generated {len(files)} file(s) — download below.", files
+
+
+# ------------------------------------------------------------------ UI ----
+CSS = """
+.gradio-container { max-width: 1100px !important; }
+footer { display: none !important; }
+"""
+
+with gr.Blocks(title="ML Data Analysis Studio", css=CSS, theme=gr.themes.Soft()) as demo:
+    gr.Markdown(
+        "# 🤖 ML Data Analysis Studio\n"
+        "Chat about machine learning, upload your data, clean it, train models, "
+        "inspect the code, and download reports."
+    )
+
+    with gr.Tabs():
+        # ---------------------------------------------------- Tab 1: Chat
+        with gr.Tab("💬 ML Assistant"):
+            gr.ChatInterface(
+                fn=chat_fn,
+                chatbot=gr.Chatbot(
+                    value=[{"role": "assistant", "content": chat_engine.WELCOME}],
+                    height=420,
+                    type="messages",
+                ),
+                type="messages",
+                examples=[
+                    "What do you want to analyse today?",
+                    "Which model should I use?",
+                    "What is a random forest?",
+                    "Explain overfitting",
+                    "What do precision and recall mean?",
+                ],
+            )
+
+        # -------------------------------------- Tab 2: Data & Preprocessing
+        with gr.Tab("📊 Data & Preprocessing"):
+            gr.Markdown("### Step 1 — Upload your dataset (CSV, TSV, Excel, JSON, or Parquet)")
+            file_input = gr.File(
+                label="Upload data",
+                file_types=[".csv", ".tsv", ".xlsx", ".xls", ".json", ".parquet", ".txt"],
+            )
+            upload_status = gr.Markdown("Upload a file to begin.")
+            data_preview = gr.Dataframe(label="Data preview (first 20 rows)")
+
+            gr.Markdown("### Step 2 — Preprocessing & cleaning options")
+            with gr.Row():
+                missing_dd = gr.Dropdown(
+                    ["Impute (mean/mode)", "Drop rows with missing values"],
+                    value="Impute (mean/mode)",
+                    label="Missing values",
+                )
+                target_dd_pre = gr.Dropdown(
+                    [], label="Target column (kept out of encoding/scaling)"
+                )
+            with gr.Row():
+                dups_cb = gr.Checkbox(True, label="Remove duplicate rows")
+                encode_cb = gr.Checkbox(True, label="One-hot encode categoricals")
+                scale_cb = gr.Checkbox(False, label="Scale numeric features (StandardScaler)")
+            preprocess_btn = gr.Button("🧹 Run Preprocessing", variant="primary")
+            preprocess_status = gr.Markdown()
+            clean_preview = gr.Dataframe(label="Cleaned data preview")
+            with gr.Accordion("👨‍💻 View preprocessing code", open=False):
+                preprocess_code = gr.Code(language="python")
+
+        # ------------------------------------------- Tab 3: Model Training
+        with gr.Tab("🧠 Model Training"):
+            gr.Markdown("### Step 3 — Configure and train a model")
+            with gr.Row():
+                target_dd = gr.Dropdown([], label="Target column (what to predict)")
+                task_radio = gr.Radio(
+                    ["Regression", "Classification"], value="Regression", label="Task"
+                )
+            with gr.Row():
+                model_dd = gr.Dropdown(
+                    list(ml_models.REGRESSION_MODELS),
+                    value="Linear Regression",
+                    label="Model",
+                )
+                test_slider = gr.Slider(0.1, 0.4, 0.2, step=0.05, label="Test set fraction")
+            train_btn = gr.Button("🚀 Train Model", variant="primary")
+            train_status = gr.Markdown()
+            with gr.Row():
+                result_plot = gr.Image(label="Result plot", type="filepath")
+                importance_plot = gr.Image(label="Feature importance", type="filepath")
+            metrics_df = gr.Dataframe(label="Metrics", visible=True)
+            with gr.Accordion("👨‍💻 View model training code", open=False):
+                model_code = gr.Code(language="python")
+
+        # ----------------------------------------------- Tab 4: Downloads
+        with gr.Tab("📥 Reports & Downloads"):
+            gr.Markdown(
+                "### Step 4 — Export your analysis\n"
+                "Generates a report with the dataset profile, preprocessing steps, "
+                "model results, and charts."
+            )
+            formats_cg = gr.CheckboxGroup(
+                ["PDF report", "HTML report", "Cleaned data (CSV)"],
+                value=["PDF report", "HTML report", "Cleaned data (CSV)"],
+                label="Formats",
+            )
+            report_btn = gr.Button("📄 Generate Downloads", variant="primary")
+            report_status = gr.Markdown()
+            report_files = gr.Files(label="Your downloads")
+
+    # ------------------------------------------------------------ wiring ----
+    file_input.change(
+        upload_fn,
+        inputs=file_input,
+        outputs=[upload_status, data_preview, target_dd_pre, preprocess_status],
+    ).then(lambda t: gr.update(choices=STATE["raw_df"].columns.tolist() if STATE["raw_df"] is not None else [], value=t),
+           inputs=target_dd_pre, outputs=target_dd)
+
+    preprocess_btn.click(
+        preprocess_fn,
+        inputs=[missing_dd, dups_cb, encode_cb, scale_cb, target_dd_pre],
+        outputs=[preprocess_status, clean_preview, preprocess_code, target_dd],
+    )
+
+    target_dd.change(suggest_task_fn, inputs=target_dd, outputs=task_radio)
+    task_radio.change(task_models_fn, inputs=task_radio, outputs=model_dd)
+
+    train_btn.click(
+        train_fn,
+        inputs=[target_dd, task_radio, model_dd, test_slider],
+        outputs=[train_status, result_plot, importance_plot, model_code, metrics_df],
+    )
+
+    report_btn.click(download_fn, inputs=formats_cg, outputs=[report_status, report_files])
+
+
+if __name__ == "__main__":
+    demo.launch()

chat_engine.py

@@ -0,0 +1,164 @@
+"""Rule-based chat assistant: ML knowledge base + guided analysis flow."""
+
+WELCOME = (
+    "Hi! I'm your ML analysis assistant. Ask me anything about machine learning "
+    "models (e.g. *'What is a random forest?'*, *'When should I use logistic "
+    "regression?'*), or upload a dataset in the **Data & Preprocessing** tab.\n\n"
+    "**So — what do you want to analyse today?**"
+)
+
+KNOWLEDGE_BASE = {
+    ("linear regression",): (
+        "**Linear Regression** fits a straight line (or hyperplane) that minimizes the "
+        "squared error between predictions and actual values. Use it when the target is "
+        "continuous and roughly linearly related to the features. Pros: fast, interpretable "
+        "coefficients. Cons: can't capture non-linear patterns, sensitive to outliers."
+    ),
+    ("logistic regression",): (
+        "**Logistic Regression** is a classification model that predicts class "
+        "probabilities via the sigmoid function. Great baseline for binary classification. "
+        "Pros: fast, well-calibrated probabilities, interpretable. Cons: linear decision "
+        "boundary only."
+    ),
+    ("random forest",): (
+        "**Random Forest** builds many decision trees on bootstrapped samples with random "
+        "feature subsets, then averages (regression) or votes (classification). Pros: "
+        "handles non-linearity, robust to outliers/overfitting, gives feature importance. "
+        "Cons: slower and less interpretable than a single tree."
+    ),
+    ("decision tree",): (
+        "**Decision Trees** split data by feature thresholds to form a flowchart of rules. "
+        "Pros: highly interpretable, no scaling needed, handles mixed data. Cons: prone to "
+        "overfitting — usually better inside an ensemble (Random Forest / Gradient Boosting)."
+    ),
+    ("gradient boosting", "xgboost", "boosting"): (
+        "**Gradient Boosting** builds trees sequentially, each one correcting the errors of "
+        "the previous ones. Often the top performer on tabular data (XGBoost/LightGBM are "
+        "popular variants). Pros: high accuracy. Cons: more hyperparameters, slower to train."
+    ),
+    ("svm", "support vector"): (
+        "**Support Vector Machines** find the boundary that maximizes the margin between "
+        "classes (SVC) or fit within an error tube (SVR). Kernels enable non-linear "
+        "boundaries. Pros: effective in high dimensions. Cons: slow on large datasets, "
+        "needs feature scaling."
+    ),
+    ("knn", "k-nearest", "nearest neighbor"): (
+        "**K-Nearest Neighbors** predicts from the K closest training points — majority "
+        "vote for classification, average for regression. Pros: simple, no training phase. "
+        "Cons: slow at prediction time, sensitive to scaling and irrelevant features."
+    ),
+    ("overfitting", "overfit"): (
+        "**Overfitting** is when a model memorizes training data (including noise) and "
+        "performs poorly on new data. Signs: high train accuracy, low test accuracy. "
+        "Remedies: more data, simpler models, regularization, cross-validation, early stopping."
+    ),
+    ("classification", "classify"): (
+        "**Classification** predicts a discrete category (spam/not-spam, species, churn). "
+        "Models here: Logistic Regression, Decision Tree, Random Forest, Gradient Boosting, "
+        "SVC, and KNN. Metrics: accuracy, precision, recall, F1."
+    ),
+    ("regression", "predict a number", "continuous"): (
+        "**Regression** predicts a continuous number (price, temperature, sales). Models "
+        "here: Linear Regression, Decision Tree, Random Forest, Gradient Boosting, SVR, and "
+        "KNN. Metrics: R², MAE, RMSE."
+    ),
+    ("preprocessing", "cleaning", "clean data", "preprocess"): (
+        "**Preprocessing** in this app: drop empty columns, remove duplicates, impute or "
+        "drop missing values, one-hot encode categoricals, and optionally scale numeric "
+        "features. The cleaned dataset is saved temporarily and reused for model training. "
+        "Head to the **Data & Preprocessing** tab to run it."
+    ),
+    ("missing value", "impute", "nan"): (
+        "**Missing values** can be dropped (safe if few) or imputed — mean/median for "
+        "numeric, mode for categorical. This app supports both strategies in the "
+        "preprocessing step."
+    ),
+    ("scaling", "standardize", "normalize"): (
+        "**Feature scaling** puts features on comparable ranges. StandardScaler (mean 0, "
+        "std 1) matters a lot for SVM and KNN; tree-based models don't need it. Enable it "
+        "in the preprocessing options."
+    ),
+    ("metric", "accuracy", "precision", "recall", "f1"): (
+        "**Classification metrics**: accuracy = overall correct rate; precision = of "
+        "predicted positives, how many were right; recall = of actual positives, how many "
+        "were found; F1 = harmonic mean of precision and recall (good for imbalanced data)."
+    ),
+    ("r2", "r²", "rmse", "mae"): (
+        "**Regression metrics**: R² = share of variance explained (1.0 is perfect); "
+        "MAE = average absolute error in target units; RMSE = like MAE but penalizes "
+        "large errors more."
+    ),
+    ("which model", "best model", "what model", "choose a model", "recommend"): (
+        "Quick guide: predicting a **number** → start with Linear Regression, then Random "
+        "Forest / Gradient Boosting. Predicting a **category** → start with Logistic "
+        "Regression, then Random Forest / Gradient Boosting. Small dataset with scaled "
+        "features → SVM or KNN are worth a try. Upload your data and I can suggest a task "
+        "type automatically from your target column."
+    ),
+    ("train test split", "test size", "split"): (
+        "**Train/test split** holds out part of the data (default 20% here) to evaluate the "
+        "model on unseen examples. Adjust it with the slider in the Model Training tab."
+    ),
+    ("feature importance",): (
+        "**Feature importance** shows which columns most influence predictions. Tree models "
+        "expose `feature_importances_`; linear models use coefficient magnitudes. This app "
+        "plots the top 15 automatically after training."
+    ),
+    ("cross validation", "cross-validation", "k-fold"): (
+        "**Cross-validation** splits data into K folds, trains K times each holding out one "
+        "fold, and averages the scores — a more reliable estimate than a single split, at "
+        "the cost of K× training time."
+    ),
+}
+
+DATA_LOADED_PROMPT = (
+    "\n\n📊 I can see you've uploaded **{name}**. Do you want me to analyse this data? "
+    "Head to the **Data & Preprocessing** tab to clean it, then train models in "
+    "**Model Training**."
+)
+
+FALLBACK = (
+    "I can help with questions about the models in this app — linear/logistic regression, "
+    "decision trees, random forests, gradient boosting, SVM, KNN — plus preprocessing, "
+    "metrics, overfitting, and train/test splits.\n\n"
+    "Or just get started: **upload your data in the Data & Preprocessing tab** and I'll "
+    "help you analyse it. What do you want to analyse today?"
+)
+
+GREETINGS = ("hi", "hello", "hey", "good morning", "good afternoon", "good evening", "yo", "hola")
+
+
+def respond(message: str, uploaded_file_name: str | None = None) -> str:
+    """Return the assistant's reply to a user message."""
+    msg = message.lower().strip()
+
+    if any(msg == g or msg.startswith(g + " ") or msg.startswith(g + "!") for g in GREETINGS):
+        reply = (
+            "Hello! I'm here to help you analyse your data with machine learning. "
+            "**What do you want to analyse today?** You can ask about any ML model, "
+            "or upload a dataset (CSV, Excel, JSON, Parquet) in the "
+            "**Data & Preprocessing** tab."
+        )
+    elif any(kw in msg for kw in ("analyse", "analyze", "analysis", "get started", "start", "upload")):
+        reply = (
+            "Great — here's the workflow:\n\n"
+            "1. **Data & Preprocessing tab** — upload your file, review the profile, and "
+            "run cleaning (missing values, duplicates, encoding, scaling).\n"
+            "2. **Model Training tab** — pick a target column, a task "
+            "(regression/classification), and a model, then train.\n"
+            "3. Review metrics and charts, open the **code dropdown** to see the exact "
+            "Python used, and **download the report** (PDF/HTML) and cleaned data.\n\n"
+            "Do you want me to analyse your data? Upload it and I'll take it from there!"
+        )
+    else:
+        reply = None
+        for keywords, answer in KNOWLEDGE_BASE.items():
+            if any(kw in msg for kw in keywords):
+                reply = answer
+                break
+        if reply is None:
+            reply = FALLBACK
+
+    if uploaded_file_name:
+        reply += DATA_LOADED_PROMPT.format(name=uploaded_file_name)
+    return reply

data_processor.py

@@ -0,0 +1,212 @@
+"""Data loading, profiling, and preprocessing utilities."""
+
+import os
+import tempfile
+
+import numpy as np
+import pandas as pd
+
+# Temp workspace that persists for the app session
+TEMP_DIR = os.path.join(tempfile.gettempdir(), "ml_analysis_space")
+os.makedirs(TEMP_DIR, exist_ok=True)
+
+CLEANED_PATH = os.path.join(TEMP_DIR, "cleaned_data.csv")
+
+SUPPORTED_EXTENSIONS = [".csv", ".tsv", ".xlsx", ".xls", ".json", ".parquet", ".txt"]
+
+
+def load_data(file_path: str) -> pd.DataFrame:
+    """Load a dataset from CSV, TSV, Excel, JSON, or Parquet."""
+    ext = os.path.splitext(file_path)[1].lower()
+    if ext in (".csv", ".txt"):
+        df = pd.read_csv(file_path)
+    elif ext == ".tsv":
+        df = pd.read_csv(file_path, sep="\t")
+    elif ext in (".xlsx", ".xls"):
+        df = pd.read_excel(file_path)
+    elif ext == ".json":
+        df = pd.read_json(file_path)
+    elif ext == ".parquet":
+        df = pd.read_parquet(file_path)
+    else:
+        raise ValueError(
+            f"Unsupported file type '{ext}'. Supported: {', '.join(SUPPORTED_EXTENSIONS)}"
+        )
+    return df
+
+
+def profile_data(df: pd.DataFrame) -> dict:
+    """Return a summary profile of the dataset."""
+    numeric_cols = df.select_dtypes(include=np.number).columns.tolist()
+    categorical_cols = df.select_dtypes(exclude=np.number).columns.tolist()
+    profile = {
+        "n_rows": int(df.shape[0]),
+        "n_cols": int(df.shape[1]),
+        "columns": df.columns.tolist(),
+        "dtypes": {c: str(t) for c, t in df.dtypes.items()},
+        "numeric_columns": numeric_cols,
+        "categorical_columns": categorical_cols,
+        "missing_counts": df.isna().sum().to_dict(),
+        "missing_total": int(df.isna().sum().sum()),
+        "duplicate_rows": int(df.duplicated().sum()),
+        "memory_kb": round(df.memory_usage(deep=True).sum() / 1024, 1),
+    }
+    return profile
+
+
+def profile_text(profile: dict) -> str:
+    """Human-readable summary of a profile dict."""
+    lines = [
+        f"**Rows:** {profile['n_rows']:,} | **Columns:** {profile['n_cols']} "
+        f"| **Memory:** {profile['memory_kb']} KB",
+        f"**Numeric columns ({len(profile['numeric_columns'])}):** "
+        + (", ".join(profile["numeric_columns"]) or "none"),
+        f"**Categorical columns ({len(profile['categorical_columns'])}):** "
+        + (", ".join(profile["categorical_columns"]) or "none"),
+        f"**Missing values:** {profile['missing_total']:,} | "
+        f"**Duplicate rows:** {profile['duplicate_rows']:,}",
+    ]
+    missing = {k: v for k, v in profile["missing_counts"].items() if v > 0}
+    if missing:
+        lines.append(
+            "**Columns with missing values:** "
+            + ", ".join(f"{k} ({v})" for k, v in missing.items())
+        )
+    return "\n\n".join(lines)
+
+
+def preprocess_data(
+    df: pd.DataFrame,
+    missing_strategy: str = "Impute (mean/mode)",
+    drop_duplicates: bool = True,
+    encode_categoricals: bool = True,
+    scale_numeric: bool = False,
+    target_column: str | None = None,
+) -> tuple[pd.DataFrame, list[str]]:
+    """Clean the dataset and return (cleaned_df, list of steps applied)."""
+    steps = []
+    df = df.copy()
+
+    # Drop columns that are entirely empty
+    empty_cols = [c for c in df.columns if df[c].isna().all()]
+    if empty_cols:
+        df = df.drop(columns=empty_cols)
+        steps.append(f"Dropped fully-empty columns: {', '.join(empty_cols)}")
+
+    # Duplicates
+    if drop_duplicates:
+        n = int(df.duplicated().sum())
+        if n:
+            df = df.drop_duplicates().reset_index(drop=True)
+            steps.append(f"Removed {n} duplicate rows")
+
+    # Missing values
+    n_missing = int(df.isna().sum().sum())
+    if n_missing:
+        if missing_strategy.startswith("Drop"):
+            before = len(df)
+            df = df.dropna().reset_index(drop=True)
+            steps.append(f"Dropped {before - len(df)} rows with missing values")
+        else:
+            for col in df.columns:
+                if df[col].isna().any():
+                    if pd.api.types.is_numeric_dtype(df[col]):
+                        df[col] = df[col].fillna(df[col].mean())
+                    else:
+                        mode = df[col].mode()
+                        df[col] = df[col].fillna(mode.iloc[0] if len(mode) else "unknown")
+            steps.append(
+                f"Imputed {n_missing} missing values (mean for numeric, mode for categorical)"
+            )
+
+    # Encode categoricals (except the target, which models handle separately)
+    if encode_categoricals:
+        cat_cols = [
+            c
+            for c in df.select_dtypes(exclude=np.number).columns
+            if c != target_column
+        ]
+        low_card = [c for c in cat_cols if df[c].nunique() <= 20]
+        high_card = [c for c in cat_cols if df[c].nunique() > 20]
+        if high_card:
+            df = df.drop(columns=high_card)
+            steps.append(
+                f"Dropped high-cardinality text columns (>20 unique): {', '.join(high_card)}"
+            )
+        if low_card:
+            df = pd.get_dummies(df, columns=low_card, drop_first=True, dtype=int)
+            steps.append(f"One-hot encoded: {', '.join(low_card)}")
+
+    # Scale numeric features
+    if scale_numeric:
+        from sklearn.preprocessing import StandardScaler
+
+        num_cols = [
+            c
+            for c in df.select_dtypes(include=np.number).columns
+            if c != target_column
+        ]
+        if num_cols:
+            df[num_cols] = StandardScaler().fit_transform(df[num_cols])
+            steps.append(f"Standard-scaled {len(num_cols)} numeric columns")
+
+    if not steps:
+        steps.append("Data was already clean — no changes needed")
+
+    df.to_csv(CLEANED_PATH, index=False)
+    steps.append(f"Saved cleaned data ({len(df):,} rows x {df.shape[1]} cols) for modeling")
+    return df, steps
+
+
+def generate_preprocessing_code(
+    missing_strategy: str,
+    drop_duplicates: bool,
+    encode_categoricals: bool,
+    scale_numeric: bool,
+    target_column: str | None,
+) -> str:
+    """Return equivalent standalone pandas code for the preprocessing performed."""
+    code = [
+        "import pandas as pd",
+        "import numpy as np",
+        "",
+        "df = pd.read_csv('your_data.csv')",
+        "",
+        "# Drop fully-empty columns",
+        "df = df.dropna(axis=1, how='all')",
+    ]
+    if drop_duplicates:
+        code += ["", "# Remove duplicate rows", "df = df.drop_duplicates().reset_index(drop=True)"]
+    if missing_strategy.startswith("Drop"):
+        code += ["", "# Drop rows with missing values", "df = df.dropna().reset_index(drop=True)"]
+    else:
+        code += [
+            "",
+            "# Impute missing values: mean for numeric, mode for categorical",
+            "for col in df.columns:",
+            "    if df[col].isna().any():",
+            "        if pd.api.types.is_numeric_dtype(df[col]):",
+            "            df[col] = df[col].fillna(df[col].mean())",
+            "        else:",
+            "            df[col] = df[col].fillna(df[col].mode().iloc[0])",
+        ]
+    if encode_categoricals:
+        code += [
+            "",
+            "# One-hot encode low-cardinality categoricals (drop high-cardinality text)",
+            f"target = {target_column!r}",
+            "cat_cols = [c for c in df.select_dtypes(exclude=np.number).columns if c != target]",
+            "df = df.drop(columns=[c for c in cat_cols if df[c].nunique() > 20])",
+            "cat_cols = [c for c in df.select_dtypes(exclude=np.number).columns if c != target]",
+            "df = pd.get_dummies(df, columns=cat_cols, drop_first=True, dtype=int)",
+        ]
+    if scale_numeric:
+        code += [
+            "",
+            "# Standard-scale numeric features",
+            "from sklearn.preprocessing import StandardScaler",
+            f"num_cols = [c for c in df.select_dtypes(include=np.number).columns if c != {target_column!r}]",
+            "df[num_cols] = StandardScaler().fit_transform(df[num_cols])",
+        ]
+    code += ["", "df.to_csv('cleaned_data.csv', index=False)"]
+    return "\n".join(code)

ml_models.py

@@ -0,0 +1,271 @@
+"""Model training, evaluation, and code generation."""
+
+import io
+import os
+
+import matplotlib
+
+matplotlib.use("Agg")
+import matplotlib.pyplot as plt
+import numpy as np
+import pandas as pd
+from sklearn.ensemble import (
+    GradientBoostingClassifier,
+    GradientBoostingRegressor,
+    RandomForestClassifier,
+    RandomForestRegressor,
+)
+from sklearn.linear_model import LinearRegression, LogisticRegression
+from sklearn.metrics import (
+    accuracy_score,
+    confusion_matrix,
+    f1_score,
+    mean_absolute_error,
+    mean_squared_error,
+    precision_score,
+    r2_score,
+    recall_score,
+)
+from sklearn.model_selection import train_test_split
+from sklearn.neighbors import KNeighborsClassifier, KNeighborsRegressor
+from sklearn.preprocessing import LabelEncoder
+from sklearn.svm import SVC, SVR
+from sklearn.tree import DecisionTreeClassifier, DecisionTreeRegressor
+
+from data_processor import TEMP_DIR
+
+REGRESSION_MODELS = {
+    "Linear Regression": LinearRegression,
+    "Decision Tree Regressor": DecisionTreeRegressor,
+    "Random Forest Regressor": RandomForestRegressor,
+    "Gradient Boosting Regressor": GradientBoostingRegressor,
+    "Support Vector Regressor (SVR)": SVR,
+    "K-Nearest Neighbors Regressor": KNeighborsRegressor,
+}
+
+CLASSIFICATION_MODELS = {
+    "Logistic Regression": LogisticRegression,
+    "Decision Tree Classifier": DecisionTreeClassifier,
+    "Random Forest Classifier": RandomForestClassifier,
+    "Gradient Boosting Classifier": GradientBoostingClassifier,
+    "Support Vector Classifier (SVC)": SVC,
+    "K-Nearest Neighbors Classifier": KNeighborsClassifier,
+}
+
+MODEL_IMPORTS = {
+    "Linear Regression": "from sklearn.linear_model import LinearRegression",
+    "Decision Tree Regressor": "from sklearn.tree import DecisionTreeRegressor",
+    "Random Forest Regressor": "from sklearn.ensemble import RandomForestRegressor",
+    "Gradient Boosting Regressor": "from sklearn.ensemble import GradientBoostingRegressor",
+    "Support Vector Regressor (SVR)": "from sklearn.svm import SVR",
+    "K-Nearest Neighbors Regressor": "from sklearn.neighbors import KNeighborsRegressor",
+    "Logistic Regression": "from sklearn.linear_model import LogisticRegression",
+    "Decision Tree Classifier": "from sklearn.tree import DecisionTreeClassifier",
+    "Random Forest Classifier": "from sklearn.ensemble import RandomForestClassifier",
+    "Gradient Boosting Classifier": "from sklearn.ensemble import GradientBoostingClassifier",
+    "Support Vector Classifier (SVC)": "from sklearn.svm import SVC",
+    "K-Nearest Neighbors Classifier": "from sklearn.neighbors import KNeighborsClassifier",
+}
+
+
+def suggest_task(df: pd.DataFrame, target: str) -> str:
+    """Suggest 'Classification' or 'Regression' based on the target column."""
+    s = df[target]
+    if not pd.api.types.is_numeric_dtype(s):
+        return "Classification"
+    if s.nunique() <= 10:
+        return "Classification"
+    return "Regression"
+
+
+def _make_model(name: str, task: str):
+    cls = (CLASSIFICATION_MODELS if task == "Classification" else REGRESSION_MODELS)[name]
+    kwargs = {}
+    if "Logistic" in name:
+        kwargs["max_iter"] = 1000
+    if "Random Forest" in name or "Gradient Boosting" in name:
+        kwargs["random_state"] = 42
+    if "Decision Tree" in name:
+        kwargs["random_state"] = 42
+    return cls(**kwargs)
+
+
+def train_model(
+    df: pd.DataFrame,
+    target: str,
+    model_name: str,
+    task: str,
+    test_size: float = 0.2,
+) -> dict:
+    """Train a model and return metrics, plot path, and predictions sample."""
+    df = df.dropna(subset=[target])
+    X = df.drop(columns=[target]).select_dtypes(include=np.number)
+    if X.empty:
+        raise ValueError("No numeric feature columns available. Run preprocessing first.")
+    y = df[target]
+
+    label_encoder = None
+    if task == "Classification" and not pd.api.types.is_numeric_dtype(y):
+        label_encoder = LabelEncoder()
+        y = pd.Series(label_encoder.fit_transform(y), index=df.index)
+
+    stratify = y if (task == "Classification" and y.value_counts().min() >= 2) else None
+    X_train, X_test, y_train, y_test = train_test_split(
+        X, y, test_size=test_size, random_state=42, stratify=stratify
+    )
+
+    model = _make_model(model_name, task)
+    model.fit(X_train, y_train)
+    y_pred = model.predict(X_test)
+
+    if task == "Classification":
+        avg = "binary" if pd.Series(y).nunique() == 2 else "weighted"
+        metrics = {
+            "Accuracy": round(accuracy_score(y_test, y_pred), 4),
+            "Precision": round(precision_score(y_test, y_pred, average=avg, zero_division=0), 4),
+            "Recall": round(recall_score(y_test, y_pred, average=avg, zero_division=0), 4),
+            "F1 Score": round(f1_score(y_test, y_pred, average=avg, zero_division=0), 4),
+        }
+        plot_path = _plot_confusion(y_test, y_pred, model_name, label_encoder)
+    else:
+        metrics = {
+            "R² Score": round(r2_score(y_test, y_pred), 4),
+            "MAE": round(mean_absolute_error(y_test, y_pred), 4),
+            "RMSE": round(float(np.sqrt(mean_squared_error(y_test, y_pred))), 4),
+        }
+        plot_path = _plot_regression(y_test, y_pred, model_name)
+
+    importance_path = _plot_importance(model, X.columns, model_name)
+
+    return {
+        "model_name": model_name,
+        "task": task,
+        "target": target,
+        "features": X.columns.tolist(),
+        "n_train": len(X_train),
+        "n_test": len(X_test),
+        "metrics": metrics,
+        "plot_path": plot_path,
+        "importance_path": importance_path,
+    }
+
+
+def _plot_confusion(y_test, y_pred, model_name, label_encoder=None):
+    cm = confusion_matrix(y_test, y_pred)
+    labels = label_encoder.classes_ if label_encoder is not None else sorted(set(y_test))
+    fig, ax = plt.subplots(figsize=(5.5, 4.5))
+    im = ax.imshow(cm, cmap="Blues")
+    ax.set_xticks(range(len(labels)), labels=[str(l) for l in labels], rotation=45, ha="right")
+    ax.set_yticks(range(len(labels)), labels=[str(l) for l in labels])
+    for i in range(cm.shape[0]):
+        for j in range(cm.shape[1]):
+            ax.text(j, i, cm[i, j], ha="center", va="center",
+                    color="white" if cm[i, j] > cm.max() / 2 else "black")
+    ax.set_xlabel("Predicted")
+    ax.set_ylabel("Actual")
+    ax.set_title(f"Confusion Matrix — {model_name}")
+    fig.colorbar(im)
+    fig.tight_layout()
+    path = os.path.join(TEMP_DIR, "result_plot.png")
+    fig.savefig(path, dpi=120)
+    plt.close(fig)
+    return path
+
+
+def _plot_regression(y_test, y_pred, model_name):
+    fig, ax = plt.subplots(figsize=(5.5, 4.5))
+    ax.scatter(y_test, y_pred, alpha=0.5, edgecolors="none")
+    lims = [min(y_test.min(), y_pred.min()), max(y_test.max(), y_pred.max())]
+    ax.plot(lims, lims, "r--", label="Perfect prediction")
+    ax.set_xlabel("Actual")
+    ax.set_ylabel("Predicted")
+    ax.set_title(f"Actual vs Predicted — {model_name}")
+    ax.legend()
+    fig.tight_layout()
+    path = os.path.join(TEMP_DIR, "result_plot.png")
+    fig.savefig(path, dpi=120)
+    plt.close(fig)
+    return path
+
+
+def _plot_importance(model, feature_names, model_name):
+    importances = None
+    if hasattr(model, "feature_importances_"):
+        importances = model.feature_importances_
+    elif hasattr(model, "coef_"):
+        coef = model.coef_
+        importances = np.abs(coef).mean(axis=0) if coef.ndim > 1 else np.abs(coef)
+    if importances is None:
+        return None
+    order = np.argsort(importances)[-15:]
+    fig, ax = plt.subplots(figsize=(6, 4.5))
+    ax.barh([feature_names[i] for i in order], importances[order], color="#4C72B0")
+    ax.set_title(f"Feature Importance — {model_name}")
+    fig.tight_layout()
+    path = os.path.join(TEMP_DIR, "importance_plot.png")
+    fig.savefig(path, dpi=120)
+    plt.close(fig)
+    return path
+
+
+def generate_model_code(model_name: str, task: str, target: str, test_size: float) -> str:
+    """Return equivalent standalone sklearn code."""
+    cls = (CLASSIFICATION_MODELS if task == "Classification" else REGRESSION_MODELS)[model_name]
+    kwargs = []
+    if "Logistic" in model_name:
+        kwargs.append("max_iter=1000")
+    if any(k in model_name for k in ("Random Forest", "Gradient Boosting", "Decision Tree")):
+        kwargs.append("random_state=42")
+    ctor = f"{cls.__name__}({', '.join(kwargs)})"
+
+    lines = [
+        "import numpy as np",
+        "import pandas as pd",
+        "from sklearn.model_selection import train_test_split",
+        MODEL_IMPORTS[model_name],
+    ]
+    if task == "Classification":
+        lines += [
+            "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score",
+            "from sklearn.preprocessing import LabelEncoder",
+        ]
+    else:
+        lines.append(
+            "from sklearn.metrics import r2_score, mean_absolute_error, mean_squared_error"
+        )
+    lines += [
+        "",
+        "df = pd.read_csv('cleaned_data.csv')",
+        f"target = {target!r}",
+        "X = df.drop(columns=[target]).select_dtypes(include=np.number)",
+        "y = df[target]",
+    ]
+    if task == "Classification":
+        lines += [
+            "if not pd.api.types.is_numeric_dtype(y):",
+            "    y = LabelEncoder().fit_transform(y)",
+        ]
+    lines += [
+        "",
+        "X_train, X_test, y_train, y_test = train_test_split(",
+        f"    X, y, test_size={test_size}, random_state=42)",
+        "",
+        f"model = {ctor}",
+        "model.fit(X_train, y_train)",
+        "y_pred = model.predict(X_test)",
+        "",
+    ]
+    if task == "Classification":
+        lines += [
+            "print('Accuracy :', accuracy_score(y_test, y_pred))",
+            "print('Precision:', precision_score(y_test, y_pred, average='weighted'))",
+            "print('Recall   :', recall_score(y_test, y_pred, average='weighted'))",
+            "print('F1 Score :', f1_score(y_test, y_pred, average='weighted'))",
+        ]
+    else:
+        lines += [
+            "print('R2  :', r2_score(y_test, y_pred))",
+            "print('MAE :', mean_absolute_error(y_test, y_pred))",
+            "print('RMSE:', np.sqrt(mean_squared_error(y_test, y_pred)))",
+        ]
+    return "\n".join(lines)

report_generator.py

@@ -0,0 +1,153 @@
+"""Generate downloadable PDF and HTML analysis reports."""
+
+import base64
+import os
+from datetime import datetime
+
+from fpdf import FPDF
+
+from data_processor import TEMP_DIR
+
+PDF_PATH = os.path.join(TEMP_DIR, "analysis_report.pdf")
+HTML_PATH = os.path.join(TEMP_DIR, "analysis_report.html")
+
+
+def _sanitize(text: str) -> str:
+    """fpdf core fonts are latin-1 only."""
+    replacements = {"²": "^2", "—": "-", "–": "-", "'": "'", "'": "'", """: '"', """: '"', "×": "x"}
+    for a, b in replacements.items():
+        text = text.replace(a, b)
+    return text.encode("latin-1", "replace").decode("latin-1")
+
+
+def generate_pdf_report(profile: dict, steps: list[str], result: dict) -> str:
+    pdf = FPDF()
+    pdf.set_auto_page_break(auto=True, margin=15)
+    pdf.add_page()
+
+    pdf.set_font("Helvetica", "B", 18)
+    pdf.cell(0, 12, "ML Data Analysis Report", ln=True)
+    pdf.set_font("Helvetica", "", 10)
+    pdf.set_text_color(120, 120, 120)
+    pdf.cell(0, 6, f"Generated {datetime.now():%Y-%m-%d %H:%M}", ln=True)
+    pdf.set_text_color(0, 0, 0)
+    pdf.ln(4)
+
+    def section(title):
+        pdf.set_font("Helvetica", "B", 13)
+        pdf.set_fill_color(230, 236, 245)
+        pdf.cell(0, 9, _sanitize(title), ln=True, fill=True)
+        pdf.ln(2)
+        pdf.set_font("Helvetica", "", 10)
+
+    def kv(key, value):
+        pdf.set_font("Helvetica", "B", 10)
+        pdf.cell(55, 6, _sanitize(str(key)))
+        pdf.set_font("Helvetica", "", 10)
+        pdf.multi_cell(0, 6, _sanitize(str(value)))
+
+    section("1. Dataset Overview")
+    kv("Rows", f"{profile['n_rows']:,}")
+    kv("Columns", profile["n_cols"])
+    kv("Numeric columns", ", ".join(profile["numeric_columns"]) or "none")
+    kv("Categorical columns", ", ".join(profile["categorical_columns"]) or "none")
+    kv("Missing values", f"{profile['missing_total']:,}")
+    kv("Duplicate rows", f"{profile['duplicate_rows']:,}")
+    pdf.ln(4)
+
+    section("2. Preprocessing Steps")
+    for i, step in enumerate(steps, 1):
+        pdf.multi_cell(0, 6, _sanitize(f"{i}. {step}"))
+    pdf.ln(4)
+
+    section("3. Model & Results")
+    kv("Model", result["model_name"])
+    kv("Task", result["task"])
+    kv("Target column", result["target"])
+    kv("Training samples", f"{result['n_train']:,}")
+    kv("Test samples", f"{result['n_test']:,}")
+    pdf.ln(2)
+    for metric, value in result["metrics"].items():
+        kv(metric, value)
+    pdf.ln(4)
+
+    for title, path in [
+        ("4. Result Plot", result.get("plot_path")),
+        ("5. Feature Importance", result.get("importance_path")),
+    ]:
+        if path and os.path.exists(path):
+            section(title)
+            pdf.image(path, w=150)
+            pdf.ln(4)
+
+    pdf.output(PDF_PATH)
+    return PDF_PATH
+
+
+def _img_b64(path):
+    if not path or not os.path.exists(path):
+        return None
+    with open(path, "rb") as f:
+        return base64.b64encode(f.read()).decode()
+
+
+def generate_html_report(profile: dict, steps: list[str], result: dict) -> str:
+    plot_b64 = _img_b64(result.get("plot_path"))
+    imp_b64 = _img_b64(result.get("importance_path"))
+
+    metrics_rows = "".join(
+        f"<tr><td>{k}</td><td><b>{v}</b></td></tr>" for k, v in result["metrics"].items()
+    )
+    steps_html = "".join(f"<li>{s}</li>" for s in steps)
+    missing = {k: v for k, v in profile["missing_counts"].items() if v > 0}
+    missing_html = (
+        ", ".join(f"{k} ({v})" for k, v in missing.items()) if missing else "None"
+    )
+
+    html = f"""<!DOCTYPE html>
+<html><head><meta charset="utf-8"><title>ML Data Analysis Report</title>
+<style>
+body {{ font-family: -apple-system, 'Segoe UI', Roboto, sans-serif; max-width: 860px;
+       margin: 40px auto; padding: 0 20px; color: #1a202c; line-height: 1.6; }}
+h1 {{ border-bottom: 3px solid #4C72B0; padding-bottom: 8px; }}
+h2 {{ color: #4C72B0; margin-top: 32px; }}
+table {{ border-collapse: collapse; width: 100%; margin: 12px 0; }}
+td, th {{ border: 1px solid #e2e8f0; padding: 8px 12px; text-align: left; }}
+th {{ background: #edf2f7; }}
+img {{ max-width: 100%; border: 1px solid #e2e8f0; border-radius: 8px; margin: 8px 0; }}
+.meta {{ color: #718096; font-size: 0.9em; }}
+</style></head><body>
+<h1>ML Data Analysis Report</h1>
+<p class="meta">Generated {datetime.now():%Y-%m-%d %H:%M}</p>
+
+<h2>1. Dataset Overview</h2>
+<table>
+<tr><th>Rows</th><td>{profile['n_rows']:,}</td></tr>
+<tr><th>Columns</th><td>{profile['n_cols']}</td></tr>
+<tr><th>Numeric columns</th><td>{', '.join(profile['numeric_columns']) or 'none'}</td></tr>
+<tr><th>Categorical columns</th><td>{', '.join(profile['categorical_columns']) or 'none'}</td></tr>
+<tr><th>Missing values</th><td>{profile['missing_total']:,} ({missing_html})</td></tr>
+<tr><th>Duplicate rows</th><td>{profile['duplicate_rows']:,}</td></tr>
+</table>
+
+<h2>2. Preprocessing Steps</h2>
+<ol>{steps_html}</ol>
+
+<h2>3. Model &amp; Results</h2>
+<table>
+<tr><th>Model</th><td>{result['model_name']}</td></tr>
+<tr><th>Task</th><td>{result['task']}</td></tr>
+<tr><th>Target</th><td>{result['target']}</td></tr>
+<tr><th>Train / test samples</th><td>{result['n_train']:,} / {result['n_test']:,}</td></tr>
+{metrics_rows}
+</table>
+"""
+    if plot_b64:
+        html += f'<h2>4. Result Plot</h2><img src="data:image/png;base64,{plot_b64}">'
+    if imp_b64:
+        html += f'<h2>5. Feature Importance</h2><img src="data:image/png;base64,{imp_b64}">'
+    html += "</body></html>"
+
+    with open(HTML_PATH, "w", encoding="utf-8") as f:
+        f.write(html)
+    return HTML_PATH

requirements.txt

@@ -0,0 +1,8 @@
+gradio>=4.44.0
+pandas>=2.0
+numpy>=1.24
+scikit-learn>=1.3
+matplotlib>=3.7
+openpyxl>=3.1
+pyarrow>=14.0
+fpdf2>=2.7