app.py

#import asyncio

#asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())

from pathlib import Path
import io
import tempfile
import traceback
import zipfile
import xml.etree.ElementTree as ET

import gradio as gr
import matplotlib.pyplot as plt
import numpy as np
import pandas as pd
import pingouin as pg
import seaborn as sns
from bs4 import BeautifulSoup
from PIL import Image

BASE = Path(__file__).parent

DATASETS = {
    "General teaching data": ("general_data.csv", "Descriptives, normality, correlations, t-tests, ANOVA, ANCOVA, and regression."),
    "Repeated-measures data": ("repeated_measures_data.csv", "Repeated-measures ANOVA and Friedman: score, time, participant."),
    "Reliability data": ("reliability_data.csv", "Cronbach alpha: select item1 through item8."),
    "Categorical data": ("categorical_data.csv", "Chi-square: treatment × outcome, adherence × outcome, or smoker × outcome."),
    "Nonparametric data": ("nonparametric_data.csv", "Mann–Whitney, Kruskal–Wallis, and Wilcoxon."),
    "Penguins (Pingouin)": (None, "A familiar dataset for descriptives, correlations, ANOVA, and regression."),
}

ANALYSES = [
    "1. Descriptive statistics",
    "2. Normality and Q-Q plot",
    "3. Correlation",
    "4. Partial correlation",
    "5. T-test",
    "6. One-way ANOVA",
    "7. Repeated-measures ANOVA",
    "8. ANCOVA",
    "9. Nonparametric test",
    "10. Linear regression",
    "11. Cronbach alpha",
    "12. Chi-square test",
    "13. Exam generator",
    "14. Statsmodels regression models",
]

EDITOR_CSS = """
#analysis-code .cm-editor {
    background: #292d30;
    color: #dddddd;
    font-family: "JetBrains Mono", "Cascadia Code", "DejaVu Sans Mono", monospace;
    font-size: 14px;
    line-height: 1.65;
}
#analysis-code .cm-gutters {
    background: #292d30;
    color: #a0a0a0;
    border-right: 1px solid #454a4e;
}
#analysis-code .cm-activeLine,
#analysis-code .cm-activeLineGutter {
    background: #343a3f;
}
#analysis-code .cm-cursor {
    border-left-color: #fda331;
}
#analysis-code .cm-selectionBackground,
#analysis-code .cm-content ::selection {
    background: #46596b !important;
}
"""

DARK_MODE_HEAD = """<script>
(() => {
    const url = new URL(window.location.href);
    if (!url.searchParams.has("__theme")) {
        url.searchParams.set("__theme", "dark");
        window.location.replace(url);
    }
})();
</script>"""


def load_data(dataset_name, uploaded):
    if uploaded:
        path = Path(uploaded)
        suffix = path.suffix.lower()
        if suffix == ".csv":
            df = pd.read_csv(path)
        elif suffix in {".xlsx", ".xls"}:
            df = pd.read_excel(path)
        elif suffix == ".sav":
            df = pd.read_spss(path)
        else:
            raise ValueError("Upload a CSV, Excel, or SPSS .sav file.")
        note = f"Uploaded file: {path.name}"
    else:
        filename, note = DATASETS[dataset_name]
        df = pg.read_dataset("penguins") if filename is None else pd.read_csv(BASE / filename)

    df.columns = [str(c).strip() for c in df.columns]
    return df, note


def defaults_for(dataset_name, all_cols, num_cols):
    def choose(name, pool, fallback=0):
        if name in pool:
            return name
        return pool[min(fallback, len(pool) - 1)] if pool else None

    x = choose("score", num_cols)
    y = choose("age", num_cols, 1)
    group = choose("group", all_cols)
    subject = choose("participant", all_cols)
    within = choose("time", all_cols)
    dv = choose("score", num_cols)
    covars = [c for c in ["age", "stress"] if c in num_cols]
    items = [c for c in num_cols if c.lower().startswith("item")]

    if dataset_name == "General teaching data":
        x = choose("pre_score", num_cols)
        y = choose("post_score", num_cols, 1)
        dv = choose("outcome", num_cols)
    elif dataset_name == "Reliability data":
        x = choose("item1", num_cols)
        y = choose("item2", num_cols, 1)
    elif dataset_name == "Categorical data":
        group = choose("treatment", all_cols)
        within = choose("outcome", all_cols, 1)
    elif dataset_name == "Nonparametric data":
        x = choose("before", num_cols)
        y = choose("after", num_cols, 1)
        dv = choose("skewed_score", num_cols)

    return x, y, group, subject, within, dv, covars, items


def refresh(dataset_name, uploaded):
    try:
        df, note = load_data(dataset_name, uploaded)
        all_cols = list(df.columns)
        num_cols = list(df.select_dtypes(include=np.number).columns)
        x, y, group, subject, within, dv, covars, items = defaults_for(dataset_name, all_cols, num_cols)
        return (
            note,
            df,
            gr.update(choices=num_cols, value=x),
            gr.update(choices=num_cols, value=y),
            gr.update(choices=all_cols, value=group),
            gr.update(choices=all_cols, value=subject),
            gr.update(choices=all_cols, value=within),
            gr.update(choices=num_cols, value=dv),
            gr.update(choices=num_cols, value=[]),
            gr.update(choices=num_cols, value=covars),
            gr.update(choices=num_cols, value=items),
            gr.update(choices=all_cols, value=dv),
            gr.update(choices=all_cols, value=[]),
            gr.update(
                choices=[str(value) for value in df[dv].dropna().unique()],
                value=[str(value) for value in df[dv].dropna().unique()],
            ),
            gr.update(choices=all_cols, value=[column for column in all_cols if column != dv][:3]),
        )
    except Exception:
        blank = gr.update(choices=[], value=None)
        return traceback.format_exc(), pd.DataFrame(), blank, blank, blank, blank, blank, blank, blank, blank, blank, blank, blank, gr.update(choices=[], value=[]), gr.update(choices=[], value=[])


def refresh_outcome_levels(dataset_name, uploaded, outcome):
    try:
        df, _ = load_data(dataset_name, uploaded)
        levels = [str(value) for value in df[outcome].dropna().unique()] if outcome in df else []
        return gr.update(choices=levels, value=levels)
    except Exception:
        return gr.update(choices=[], value=[])


def update_analysis_controls(analysis, t_design, nonparametric_test, model_family):
    visible = {
        name: False
        for name in (
            "x", "y", "dv", "group", "within", "subject", "selected_vars",
            "covars", "items", "categorical_predictors", "method", "t_design",
            "test_value", "anova_type", "posthoc_type", "nonparametric_test",
            "model_family", "glm_family", "model_outcome", "outcome_order",
            "model_predictors",
        )
    }

    def show(*names):
        for name in names:
            visible[name] = True

    analysis = analysis or ""
    if analysis.startswith("1."):
        show("selected_vars")
    elif analysis.startswith("2."):
        show("x")
    elif analysis.startswith("3."):
        show("x", "y", "method")
    elif analysis.startswith("4."):
        show("x", "y", "covars")
    elif analysis.startswith("5."):
        show("t_design")
        if t_design == "One sample":
            show("x", "test_value")
        elif t_design == "Paired":
            show("x", "y")
        else:
            show("dv", "group")
    elif analysis.startswith("6."):
        show("dv", "group", "anova_type", "posthoc_type")
    elif analysis.startswith("7."):
        show("dv", "within", "subject")
    elif analysis.startswith("8."):
        show("dv", "group", "covars")
    elif analysis.startswith("9."):
        show("nonparametric_test")
        if nonparametric_test == "Mann-Whitney":
            show("dv", "group")
        elif nonparametric_test == "Wilcoxon":
            show("x", "y")
        elif nonparametric_test == "Kruskal-Wallis":
            show("dv", "group")
        elif nonparametric_test == "Friedman":
            show("dv", "within", "subject")
    elif analysis.startswith("10."):
        show("dv", "selected_vars")
    elif analysis.startswith("11."):
        show("items")
    elif analysis.startswith("12."):
        show("group", "within")
    elif analysis.startswith("14."):
        show("model_family", "model_outcome", "model_predictors", "categorical_predictors")
        if model_family == "GLM":
            show("glm_family")
        if model_family == "Ordinal logit":
            show("outcome_order")

    return [gr.update(visible=visible[name]) for name in visible]


def build_code(analysis, x, y, group, subject, within, dv, selected_vars, covars, items,
               method, t_design, test_value, anova_type, posthoc_type, nonparametric_test,
               model_family, glm_family, model_outcome, outcome_order, categorical_predictors,
               model_predictors):
    selected_vars = selected_vars or []
    covars = covars or []
    items = items or []

    if analysis.startswith("1."):
        vars_ = selected_vars or [c for c in [x, y] if c]
        return "\n".join([
            f"x = df[{vars_!r}]",
            "result = pd.DataFrame({",
            '    "N": x.count(),',
            '    "Missing": x.isna().sum(),',
            '    "Mean": x.mean(),',
            '    "SD": x.std(),',
            '    "Median": x.median(),',
            '    "Minimum": x.min(),',
            '    "Maximum": x.max(),',
            '    "Skewness": x.skew(),',
            '    "Kurtosis": x.kurt()',
            "})",
        ])

    if analysis.startswith("2."):
        return "\n".join([
            f"result = pg.normality(df[{x!r}].dropna())",
            f"sns.histplot(df[{x!r}].dropna(), kde=True)",
            f'plt.title("Distribution of {x}")',
            "plt.show()",
            f"pg.qqplot(df[{x!r}].dropna())",
            f'plt.title("Q-Q plot of {x}")',
            "plt.show()",
        ])

    if analysis.startswith("3."):
        return "\n".join([
            f"result = pg.corr(x=df[{x!r}], y=df[{y!r}], method={method!r})",
            f"sns.regplot(data=df, x={x!r}, y={y!r})",
            "plt.show()",
        ])

    if analysis.startswith("4."):
        return f"result = pg.partial_corr(data=df, x={x!r}, y={y!r}, covar={covars!r})"

    if analysis.startswith("5."):
        if t_design == "One sample":
            return f"result = pg.ttest(df[{x!r}].dropna(), {float(test_value)})"
        if t_design == "Paired":
            return f"d = df[[{x!r}, {y!r}]].dropna()\nresult = pg.ttest(d[{x!r}], d[{y!r}], paired=True)"
        return "\n".join([
            f"levels = list(df[{group!r}].dropna().unique())",
            'if len(levels) != 2: raise ValueError("Independent t-test requires exactly two groups.")',
            f"a = df.loc[df[{group!r}] == levels[0], {dv!r}].dropna()",
            f"b = df.loc[df[{group!r}] == levels[1], {dv!r}].dropna()",
            "result = pg.ttest(a, b)",
        ])

    if analysis.startswith("6."):
        code = (f"result = pg.anova(data=df, dv={dv!r}, between={group!r}, detailed=True)"
                if anova_type == "Classical"
                else f"result = pg.welch_anova(data=df, dv={dv!r}, between={group!r})")
        if posthoc_type == "Tukey":
            code += f"\nposthoc = pg.pairwise_tukey(data=df, dv={dv!r}, between={group!r})"
        elif posthoc_type == "Games-Howell":
            code += f"\nposthoc = pg.pairwise_gameshowell(data=df, dv={dv!r}, between={group!r})"
        return code

    if analysis.startswith("7."):
        return "\n".join([
            f"d = df[[{subject!r}, {within!r}, {dv!r}]].dropna().copy()",
            f"counts = d.groupby({subject!r})[{within!r}].nunique()",
            "valid = counts[counts >= 2].index",
            f"d = d[d[{subject!r}].isin(valid)]",
            f'if d.empty or d[{within!r}].nunique() < 2: raise ValueError("No valid repeated observations.")',
            f"result = pg.rm_anova(data=d, dv={dv!r}, within={within!r}, subject={subject!r}, detailed=True)",
            f"posthoc = pg.pairwise_tests(data=d, dv={dv!r}, within={within!r}, subject={subject!r}, padjust='holm')",
        ])

    if analysis.startswith("8."):
        return f"result = pg.ancova(data=df, dv={dv!r}, between={group!r}, covar={covars!r})"

    if analysis.startswith("9."):
        if nonparametric_test == "Mann-Whitney":
            return "\n".join([
                f"levels = list(df[{group!r}].dropna().unique())",
                'if len(levels) < 2: raise ValueError("At least two groups are required.")',
                f"a = df.loc[df[{group!r}] == levels[0], {dv!r}].dropna()",
                f"b = df.loc[df[{group!r}] == levels[1], {dv!r}].dropna()",
                "result = pg.mwu(a, b)",
            ])
        if nonparametric_test == "Wilcoxon":
            return f"d = df[[{x!r}, {y!r}]].dropna()\nresult = pg.wilcoxon(d[{x!r}], d[{y!r}])"
        if nonparametric_test == "Kruskal-Wallis":
            return f"result = pg.kruskal(data=df, dv={dv!r}, between={group!r})"
        return f"d = df[[{subject!r}, {within!r}, {dv!r}]].dropna()\nresult = pg.friedman(data=d, dv={dv!r}, within={within!r}, subject={subject!r})"

    if analysis.startswith("10."):
        predictors = selected_vars or [x]
        return f"result = pg.linear_regression(X=df[{predictors!r}], y=df[{dv!r}], remove_na=True)"

    if analysis.startswith("11."):
        return "\n".join([
            f"alpha, ci = pg.cronbach_alpha(data=df[{items!r}])",
            'result = pd.DataFrame({"Cronbach alpha": [alpha], "CI lower": [ci[0]], "CI upper": [ci[1]]})',
        ])

    if analysis.startswith("14."):
        outcome = model_outcome or dv
        predictors = model_predictors or [c for c in [x, y] if c and c != outcome]
        categorical_predictors = categorical_predictors or []
        terms = [
            f"C(Q({column!r}))" if column in categorical_predictors else f"Q({column!r})"
            for column in predictors
        ]
        rhs = " + ".join(terms) or "1"
        selected = [outcome, *predictors]
        if model_family == "OLS (ANOVA / ANCOVA)":
            return f'''import statsmodels.formula.api as smf
from statsmodels.stats.anova import anova_lm

d = df[{selected!r}].dropna().copy()
model = smf.ols(formula={f"Q({outcome!r}) ~ {rhs}"!r}, data=d).fit()
result = model.summary2().tables[1]
overall = pd.DataFrame({{"F": [model.fvalue], "df_model": [model.df_model], "p-value": [model.f_pvalue]}})
anova = anova_lm(model, typ=2)'''
        if model_family in {"Logit (binary)", "Probit (binary)"}:
            fit = "logit" if model_family.startswith("Logit") else "probit"
            return f'''import statsmodels.formula.api as smf
from scipy.stats import chi2

d = df[{selected!r}].dropna().copy()
d["__outcome"] = pd.Categorical(d[{outcome!r}]).codes
if d["__outcome"].nunique() != 2:
    raise ValueError("The selected outcome must have exactly two levels.")
model = smf.{fit}(formula={f"__outcome ~ {rhs}"!r}, data=d).fit(disp=False)
result = pd.DataFrame({{"coef": model.params, "SE": model.bse, "z": model.tvalues, "p-value": model.pvalues}})
overall = pd.DataFrame({{"LR chi2": [model.llr], "df": [model.df_model], "p-value": [model.llr_pvalue]}})'''
        if model_family == "Ordinal logit":
            levels = outcome_order or []
            return f'''import numpy as np
import patsy
from scipy.stats import chi2
from statsmodels.miscmodels.ordinal_model import OrderedModel

d = df[{selected!r}].dropna().copy()
d["__outcome"] = pd.Categorical(d[{outcome!r}].astype(str), categories={levels!r}, ordered=True).codes
if (d["__outcome"] < 0).any() or d["__outcome"].nunique() < 2:
    raise ValueError("Select all outcome levels in their intended order.")
X = patsy.dmatrix({rhs!r}, d, return_type="dataframe").drop(columns="Intercept", errors="ignore")
if X.empty:
    raise ValueError("Select at least one predictor for ordinal logit.")
model = OrderedModel(d["__outcome"], X, distr="logit").fit(method="bfgs", disp=False)
result = pd.DataFrame({{"coef": model.params.loc[X.columns], "SE": model.bse.loc[X.columns], "z": model.tvalues.loc[X.columns], "p-value": model.pvalues.loc[X.columns]}})
null_model = OrderedModel(d["__outcome"], np.empty((len(d), 0)), distr="logit").fit(method="bfgs", disp=False)
lr_chi2 = 2 * (model.llf - null_model.llf)
overall = pd.DataFrame({{"LR chi2": [lr_chi2], "df": [X.shape[1]], "p-value": [chi2.sf(lr_chi2, X.shape[1])]}})'''
        family = {
            "Poisson": "sm.families.Poisson()",
            "Negative binomial": "sm.families.NegativeBinomial()",
            "Gaussian": "sm.families.Gaussian()",
            "Binomial": "sm.families.Binomial()",
            "Gamma": "sm.families.Gamma()",
        }.get(glm_family or "Gaussian", "sm.families.Gaussian()")
        response = f'd["__outcome"] = pd.Categorical(d[{outcome!r}]).codes\n' if glm_family == "Binomial" else ""
        glm_outcome = "__outcome" if glm_family == "Binomial" else f"Q({outcome!r})"
        return f'''import statsmodels.api as sm
import statsmodels.formula.api as smf
from scipy.stats import chi2

d = df[{selected!r}].dropna().copy()
{response}family = {family}
model = smf.glm(formula={f"{glm_outcome} ~ {rhs}"!r}, data=d, family=family).fit()
result = pd.DataFrame({{"coef": model.params, "SE": model.bse, "z": model.tvalues, "p-value": model.pvalues}})
null_model = smf.glm(formula={f"{glm_outcome} ~ 1"!r}, data=d, family=family).fit()
lr_chi2 = max(0, 2 * (model.llf - null_model.llf))
lr_df = model.df_model - null_model.df_model
overall = pd.DataFrame({{"LR chi2": [lr_chi2], "df": [lr_df], "p-value": [chi2.sf(lr_chi2, lr_df)]}})'''

    if analysis.startswith("13."):
        return "# Generate exam versions in the Exam generator tab."
    return f"expected, observed, result = pg.chi2_independence(data=df, x={group!r}, y={within!r})"


def _as_frame(value):
    if isinstance(value, pd.Series):
        frame = value.to_frame(name=value.name or "Value")
        if isinstance(value.index, pd.MultiIndex):
            return frame.reset_index()
        return frame.rename_axis(value.index.name or "Statistic").reset_index()
    if isinstance(value, pd.DataFrame):
        if (
            isinstance(value.index, pd.RangeIndex)
            and value.index.name is None
            and value.index.equals(pd.RangeIndex(len(value)))
        ):
            return value
        if isinstance(value.index, pd.MultiIndex):
            return value.reset_index()
        index_name = value.index.name or (
            "Statistic" if all(isinstance(label, str) for label in value.index) else "Index"
        )
        return value.rename_axis(index_name).reset_index()
    if pd.api.types.is_scalar(value):
        return pd.DataFrame({"value": [value]})
    try:
        return pd.DataFrame(value)
    except (TypeError, ValueError):
        return pd.DataFrame({"value": [repr(value)]})


def run_code(dataset_name, uploaded, edited_data, code):
    try:
        df, _ = load_data(dataset_name, uploaded)
        if isinstance(edited_data, pd.DataFrame) and not edited_data.empty:
            df = edited_data.copy()
        env = {"df": df.copy(), "pd": pd, "np": np, "pg": pg, "sns": sns, "plt": plt}
        plt.close("all")
        exec(code, env)
        outputs = []
        named_outputs = [(name, env[name]) for name in ["result", "posthoc", "observed", "expected", "overall", "anova"] if name in env]
        for name in ["result", "posthoc", "observed", "expected", "overall", "anova"]:
            outputs.append(_as_frame(env[name]) if name in env else pd.DataFrame())
        figures = []
        plot_pngs = []
        for number in plt.get_fignums():
            image_buffer = io.BytesIO()
            plt.figure(number).savefig(image_buffer, format="png", bbox_inches="tight")
            png_data = image_buffer.getvalue()
            plot_pngs.append(png_data)
            figures.append(Image.open(io.BytesIO(png_data)).convert("RGB"))
        with tempfile.NamedTemporaryFile(prefix="statistics-results-", suffix=".zip", delete=False) as archive_file:
            archive_path = archive_file.name
        with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_DEFLATED) as archive:
            archive.writestr("data.csv", df.to_csv(index=False))
            archive.writestr("analysis.py", code or "")
            for name, value in named_outputs:
                archive.writestr(f"{name}.csv", _as_frame(value).to_csv(index=False))
            for index, png_data in enumerate(plot_pngs, start=1):
                archive.writestr(f"plot_{index}.png", png_data)
        return (*outputs, figures, "Analysis completed.", archive_path)
    except Exception:
        return *(pd.DataFrame() for _ in range(6)), [], traceback.format_exc(), None


def load_python_file(uploaded_code):
    if not uploaded_code:
        return gr.update()
    try:
        return Path(uploaded_code).read_text(encoding="utf-8-sig")
    except UnicodeDecodeError:
        raise gr.Error("The selected Python file must use UTF-8 encoding.")


def save_python_file(code):
    with tempfile.NamedTemporaryFile(mode="w", suffix=".py", prefix="analysis-", encoding="utf-8", delete=False) as output:
        output.write(code or "")
        return output.name


def save_dataframe_csv(data):
    if not isinstance(data, pd.DataFrame):
        data = pd.DataFrame(data)
    with tempfile.NamedTemporaryFile(mode="w", suffix=".csv", prefix="data-", encoding="utf-8", delete=False) as output:
        data.to_csv(output, index=False)
        return output.name


def generate_exam_package(uploaded_qti, num_tests, compact):
    if not uploaded_qti:
        raise gr.Error("Upload a QTI XML file first.")
    try:
        root = ET.parse(uploaded_qti).getroot()
        questions = []
        for item in root.iter():
            if not item.tag.endswith("item"):
                continue
            prompt = item.find(".//{*}presentation//{*}mattext")
            question_text = BeautifulSoup(prompt.text or "", "html.parser").get_text(" ", strip=True) if prompt is not None else ""
            options = []
            id_to_text = {}
            for label in item.findall(".//{*}response_label"):
                option = label.find(".//{*}mattext")
                text = BeautifulSoup(option.text or "", "html.parser").get_text(" ", strip=True) if option is not None else ""
                options.append(text)
                id_to_text[label.attrib.get("ident", "")] = text
            correct = ""
            for condition in item.findall(".//{*}respcondition"):
                score = condition.find(".//{*}setvar")
                answer = condition.find(".//{*}varequal")
                if score is not None and float((score.text or "0").strip()) == 100 and answer is not None:
                    correct = id_to_text.get((answer.text or "").strip(), "")
                    break
            if question_text:
                questions.append({"question": question_text, "options": options, "correct": correct})
        if not questions:
            raise ValueError("No questions were found in the QTI file.")
        with tempfile.NamedTemporaryFile(suffix=".zip", prefix="exam-versions-", delete=False) as output:
            archive_path = output.name
        with zipfile.ZipFile(archive_path, "w", zipfile.ZIP_DEFLATED) as archive:
            for test_num in range(1, int(num_tests) + 1):
                rng = np.random.default_rng(test_num)
                shuffled = questions.copy()
                rng.shuffle(shuffled)
                test_lines, answer_key = [], []
                for question_num, question in enumerate(shuffled, start=1):
                    options = question["options"].copy()
                    rng.shuffle(options)
                    option_lines = [f"{chr(65 + index)}) {option}" for index, option in enumerate(options)]
                    correct_letter = next((chr(65 + index) for index, option in enumerate(options) if option == question["correct"]), "")
                    if compact:
                        test_lines.append(f"{question_num}. {question['question']}    " + "    ".join(option_lines))
                    else:
                        test_lines.append(f"{question_num}. {question['question']}\n" + "\n".join(option_lines))
                    answer_key.append({"Question": question_num, "Answer": correct_letter, "Correct_Text": question["correct"]})
                archive.writestr(f"test{test_num}.txt", "\n\n".join(test_lines))
                archive.writestr(f"key{test_num}.csv", pd.DataFrame(answer_key).to_csv(index=False))
        return archive_path, f"Generated {int(num_tests)} versions from {len(questions)} questions."
    except Exception as error:
        raise gr.Error(f"Could not generate exams: {error}")


with gr.Blocks(title="Student Statistics Lab — Gradio") as demo:
    gr.Markdown("# Student Statistics Lab\nStatistical analyses, editable Python, and teaching-data tools.")

    with gr.Row():
        with gr.Column(scale=1):
            dataset = gr.Dropdown(list(DATASETS), value="General teaching data", label="Built-in teaching dataset")
            upload = gr.File(label="Or upload CSV, Excel, or SAV", file_types=[".csv", ".xlsx", ".xls", ".sav"], type="filepath")
            dataset_note = gr.Markdown()
            analysis = gr.Dropdown(ANALYSES, value=ANALYSES[0], label="Analysis")
        with gr.Column(scale=2):
            preview = gr.Dataframe(label="Editable data preview", interactive=True, max_height=420)
            download_dataframe = gr.DownloadButton("Download dataframe (.csv)")
            download_dataframe.click(save_dataframe_csv, [preview], [download_dataframe])

    with gr.Accordion("Variables and options", open=True):
        with gr.Row():
            x = gr.Dropdown(label="Variable X / Variable 1")
            y = gr.Dropdown(label="Variable Y / Variable 2")
            dv = gr.Dropdown(label="Dependent/outcome variable")
        with gr.Row():
            group = gr.Dropdown(label="Grouping/factor/row variable")
            within = gr.Dropdown(label="Within factor/column variable")
            subject = gr.Dropdown(label="Subject ID")
        with gr.Row():
            selected_vars = gr.Dropdown(multiselect=True, label="Variables / predictors")
            covars = gr.Dropdown(multiselect=True, label="Covariates")
            items = gr.Dropdown(multiselect=True, label="Scale items")
            categorical_predictors = gr.Dropdown(multiselect=True, label="Categorical predictors")
        with gr.Row():
            method = gr.Dropdown(["pearson", "spearman", "kendall", "bicor"], value="pearson", label="Correlation method")
            t_design = gr.Dropdown(["One sample", "Paired", "Independent"], value="Independent", label="T-test design")
            test_value = gr.Number(value=0, label="One-sample test value")
        with gr.Row():
            anova_type = gr.Dropdown(["Classical", "Welch"], value="Classical", label="ANOVA type")
            posthoc_type = gr.Dropdown(["None", "Tukey", "Games-Howell"], value="None", label="Post hoc")
            nonparametric_test = gr.Dropdown(["Mann-Whitney", "Wilcoxon", "Kruskal-Wallis", "Friedman"], value="Mann-Whitney", label="Nonparametric test")
        with gr.Row():
            model_family = gr.Dropdown(
                ["OLS (ANOVA / ANCOVA)", "Logit (binary)", "Probit (binary)", "Ordinal logit", "GLM"],
                value="OLS (ANOVA / ANCOVA)", label="Statsmodels family",
            )
            glm_family = gr.Dropdown(
                ["Poisson", "Negative binomial", "Gaussian", "Binomial", "Gamma"],
                value="Gaussian", label="GLM distribution",
            )
            model_outcome = gr.Dropdown(label="Statsmodels outcome")
            outcome_order = gr.Dropdown(multiselect=True, label="Ordinal outcome order")
            model_predictors = gr.Dropdown(multiselect=True, label="Statsmodels predictors")

    generate = gr.Button("Generate code")
    code = gr.Code(
        label="Editable Python code",
        language="python",
        interactive=True,
        lines=22,
        max_lines=36,
        wrap_lines=True,
        autocomplete=True,
        buttons=["copy"],
        elem_id="analysis-code",
    )
    with gr.Row():
        code_upload = gr.File(label="Import Python code", file_types=[".py"], type="filepath")
        load_code = gr.Button("Load into editor")
        download_code = gr.DownloadButton("Download .py")
    load_code.click(load_python_file, [code_upload], [code])
    download_code.click(save_python_file, [code], [download_code])
    run = gr.Button("Run analysis", variant="primary")
    status = gr.Textbox(label="Status / error", lines=8)

    with gr.Tabs():
        with gr.Tab("Result"):
            result = gr.Dataframe(interactive=False)
        with gr.Tab("Post hoc"):
            posthoc = gr.Dataframe(interactive=False)
        with gr.Tab("Observed"):
            observed = gr.Dataframe(interactive=False)
        with gr.Tab("Expected"):
            expected = gr.Dataframe(interactive=False)
        with gr.Tab("Overall model"):
            overall = gr.Dataframe(interactive=False)
        with gr.Tab("ANOVA table"):
            anova = gr.Dataframe(interactive=False)
        with gr.Tab("Plots"):
            plots = gr.Gallery(label="Plots", columns=2, object_fit="contain")
        with gr.Tab("Exam generator"):
            qti_upload = gr.File(label="Upload QTI XML", file_types=[".xml"], type="filepath")
            exam_count = gr.Number(label="Number of test versions", value=4, minimum=1, maximum=100, step=1)
            compact_exam = gr.Checkbox(label="Compact one-line format", value=True)
            generate_exams = gr.Button("Generate exam package", variant="primary")
            exam_status = gr.Textbox(label="Exam generation status")
            exam_download = gr.DownloadButton("Download ZIP package")
            generate_exams.click(
                generate_exam_package,
                [qti_upload, exam_count, compact_exam],
                [exam_download, exam_status],
            )
        with gr.Tab("Downloads"):
            results_download = gr.DownloadButton("Download data, code, results, and plots (.zip)")

    analysis_controls = {
        "x": x,
        "y": y,
        "dv": dv,
        "group": group,
        "within": within,
        "subject": subject,
        "selected_vars": selected_vars,
        "covars": covars,
        "items": items,
        "categorical_predictors": categorical_predictors,
        "method": method,
        "t_design": t_design,
        "test_value": test_value,
        "anova_type": anova_type,
        "posthoc_type": posthoc_type,
        "nonparametric_test": nonparametric_test,
        "model_family": model_family,
        "glm_family": glm_family,
        "model_outcome": model_outcome,
        "outcome_order": outcome_order,
        "model_predictors": model_predictors,
    }
    visibility_inputs = [analysis, t_design, nonparametric_test, model_family]
    visibility_outputs = list(analysis_controls.values())
    demo.load(update_analysis_controls, visibility_inputs, visibility_outputs)
    analysis.change(update_analysis_controls, visibility_inputs, visibility_outputs)
    t_design.change(update_analysis_controls, visibility_inputs, visibility_outputs)
    nonparametric_test.change(update_analysis_controls, visibility_inputs, visibility_outputs)
    model_family.change(update_analysis_controls, visibility_inputs, visibility_outputs)

    refresh_inputs = [dataset, upload]
    refresh_outputs = [dataset_note, preview, x, y, group, subject, within, dv,
                       selected_vars, covars, items, model_outcome, categorical_predictors,
                       outcome_order, model_predictors]
    demo.load(refresh, refresh_inputs, refresh_outputs)
    dataset.change(refresh, refresh_inputs, refresh_outputs)
    upload.change(refresh, refresh_inputs, refresh_outputs)
    model_outcome.change(refresh_outcome_levels, [dataset, upload, model_outcome], [outcome_order])

    code_inputs = [analysis, x, y, group, subject, within, dv, selected_vars, covars, items,
                   method, t_design, test_value, anova_type, posthoc_type, nonparametric_test,
                   model_family, glm_family, model_outcome, outcome_order, categorical_predictors,
                   model_predictors]
    generate.click(build_code, code_inputs, code)
    run.click(
        run_code,
        [dataset, upload, preview, code],
        [result, posthoc, observed, expected, overall, anova, plots, status, results_download],
    )

if __name__ == "__main__":
    demo.launch(
        server_name="0.0.0.0",
        server_port=7860,
        ssr_mode=False,
        css=EDITOR_CSS,
        head=DARK_MODE_HEAD,
    )