Update app.py

app.py

@@ -1,163 +1,353 @@
-# mcp_tools.py
+# app.py
+import asyncio
+asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
 
-import numpy as np
-import pingouin as pg
+import gradio as gr
+import mcp_tools
+from mcp_tools import posthoc_tests, assumption_checks
 
-import matplotlib.pyplot as plt
-import io
-import base64
-import json
-def plot_group_distribution(groups_str):
-    groups = [np.array([float(x) for x in g.split(",")]) for g in groups_str.split(";")]
-
-    fig, axes = plt.subplots(1, 3, figsize=(12, 4))
-
-    # Histogram
-    for g in groups:
-        axes[0].hist(g, alpha=0.5)
-    axes[0].set_title("Histogram")
+import spaces
 
-    # Boxplot
-    axes[1].boxplot(groups)
-    axes[1].set_title("Boxplot")
-
-    # QQ plot (first group)
-    pg.qqplot(groups[0], ax=axes[2])
-    axes[2].set_title("QQ Plot (Group 1)")
-
-    buf = io.BytesIO()
-    fig.savefig(buf, format="png")
-    buf.seek(0)
-    return base64.b64encode(buf.read()).decode()
+@spaces.GPU
+def init_gpu():
+    return "GPU initialized"
 
-def assumption_checks(groups_str):
-    import pandas as pd
+import json, tempfile, os
 
-    groups = [np.array([float(x) for x in g.split(",")]) for g in groups_str.split(";")]
+def save_json_to_file(data, filename):
+    path = os.path.join(tempfile.gettempdir(), filename)
+    with open(path, "w") as f:
+        json.dump(data, f)
+    return path
 
+import base64
 
-    # Normality (Shapiro) with safety guard
-    normality = []
-    
-    for i, g in enumerate(groups):
-        if len(g) < 4:
-            normality.append({
-                "group": f"G{i+1}",
-                "error": "Normality test requires at least 4 samples."
-            })
-        else:
-            result = pg.normality(g).to_dict(orient="records")[0]
-            normality.append({
-                "group": f"G{i+1}",
-                **result
-            })
-    
-
-    # Homogeneity (Levene)
-    levene = pg.homoscedasticity(groups, method="levene").to_dict(orient="records")[0]
-
-    return {
-        "normality": normality,
-        "homogeneity": levene
-    }
+def save_png_to_file(img, filename):
+    if img is None:
+        return None
+    img.save(filename, format="PNG")
+    return filename
 
-def posthoc_tests(groups_str, method="games-howell"):
-    import pandas as pd
 
-    groups = [np.array([float(x) for x in g.split(",")]) for g in groups_str.split(";")]
 
-    data = []
-    for i, g in enumerate(groups):
-        for val in g:
-            data.append({"value": val, "group": f"G{i+1}"})
+from io import BytesIO
+from PIL import Image
+import matplotlib.pyplot as plt
 
-    df = pd.DataFrame(data)
+def ui_plot(groups_str):
+    # Parse semicolon-separated groups
+    groups = []
+    for g in groups_str.split(";"):
+        nums = [float(x) for x in g.split(",")]
+        groups.append(nums)
+
+    # Example plot: boxplot of groups
+    fig, ax = plt.subplots()
+    ax.boxplot(groups)
+    ax.set_title("Group Plot")
+    ax.set_xlabel("Group")
+    ax.set_ylabel("Value")
+
+    buf = BytesIO()
+    fig.savefig(buf, format="png")
+    buf.seek(0)
 
-    result = pg.pairwise_ttests(
-        dv="value",
-        between="group",
-        data=df,
-        padjust="bonf",
-        parametric=(method == "tukey"),
-        effsize="hedges"
-    )
+    return Image.open(buf)
 
-    return result.to_dict(orient="records")
 
 # -----------------------------
-# Helper: convert Pingouin DF → JSON
+# UI helper wrappers
 # -----------------------------
-def pg_to_json(df):
-    """Convert Pingouin single-row DataFrame to JSON dict."""
-    return df.to_dict(orient="records")[0]
+def ui_welch(g1, g2, alt):
+    return mcp_tools.welch_t_test(g1, g2, alt)
 
+def ui_student(g1, g2, alt):
+    return mcp_tools.student_t_test(g1, g2, alt)
 
-# -----------------------------
-# Welch t-test (independent, unequal variances)
-# -----------------------------
-def welch_t_test(group1_str, group2_str, alternative="two-sided"):
-    g1 = np.array([float(x) for x in group1_str.split(",")])
-    g2 = np.array([float(x) for x in group2_str.split(",")])
+def ui_paired(g1, g2, alt):
+    return mcp_tools.paired_t_test(g1, g2, alt)
 
-    result = pg.ttest(g1, g2, paired=False, correction=True, alternative=alternative)
-    return pg_to_json(result)
+#def ui_one_sample(g, mu, alt):
+#    return mcp_tools.one_sample_t_test(g, mu, alt)
 
+def parse_group(text):
+    # Split on commas, strip whitespace, convert to float
+    return [float(x.strip()) for x in text.split(",") if x.strip()]
+    
+def ui_os(g, mu, alternative):
+    import numpy as np
+    import pingouin as pg
 
-# -----------------------------
-# Student t-test (independent, equal variances)
-# -----------------------------
-def student_t_test(group1_str, group2_str, alternative="two-sided"):
-    g1 = np.array([float(x) for x in group1_str.split(",")])
-    g2 = np.array([float(x) for x in group2_str.split(",")])
+    g = np.array(parse_group(g), dtype=float)
 
-    result = pg.ttest(g1, g2, paired=False, correction=False, alternative=alternative)
-    return pg_to_json(result)
+    if mu is None:
+        mu = 0
+    mu = float(mu)
 
+    adjusted = g - mu
+    result = pg.ttest(adjusted, y=None, alternative=alternative)
+    print("DEBUG ui_os:", g, mu, alternative)
 
-# -----------------------------
-# Paired t-test (same subjects measured twice)
-# -----------------------------
-def paired_t_test(group1_str, group2_str, alternative="two-sided"):
-    g1 = np.array([float(x) for x in group1_str.split(",")])
-    g2 = np.array([float(x) for x in group2_str.split(",")])
+    return {
+        "T": float(result["T"].iloc[0]),
+        "dof": int(result["dof"].iloc[0]),
+        "alternative": alternative,
+        "p_val": float(result["p-val"].iloc[0]),
+        "CI95": [float(result["CI95%"].iloc[0][0]), float(result["CI95%"].iloc[0][1])],
+        "cohen_d": float(result["cohen-d"].iloc[0]),
+        "power": float(result["power"].iloc[0]),
+        "BF10": str(result["BF10"].iloc[0])
+    }
 
-    result = pg.ttest(g1, g2, paired=True, alternative=alternative)
-    return pg_to_json(result)
+def ui_anova(groups):
+    return mcp_tools.one_way_anova(groups)
 
 
 # -----------------------------
-# One-sample t-test (sample vs population mean)
+# Modern Light Theme
 # -----------------------------
-def one_sample_t_test(group_str, population_mean, alternative="two-sided"):
-    g = np.array([float(x) for x in group_str.split(",")])
+theme = gr.themes.Soft(
+    primary_hue="blue",
+    secondary_hue="gray",
+    neutral_hue="gray",
+)
 
-    # Adjust sample for one-sample t-test
-    adjusted = g - float(population_mean)
 
-    # Pingouin one-sample t-test: y=None, popmean implicitly = 0
-    result = pg.ttest(adjusted, y=None, paired=False, alternative=alternative)
+# -----------------------------
+# Main UI
+# -----------------------------
+with gr.Blocks(title="Stat3001 — Statistical Tests") as demo:
 
-    return pg_to_json(result)
+    gr.Markdown(
+        """
+        # 📊 Stat3001 — Statistical Analysis Toolkit  
+        Clean, modern, and powered by **Pingouin** for robust statistical results.
+        """
+    )
+    groups_input = gr.Textbox(
+        label="Groups (semicolon-separated)",
+        placeholder="Example: 1,2,3; 4,5,6; 7,8,9",
+        value="1,2,3; 4,5,6; 7,8,9"
+    )
+    load_example = gr.Button("Load example")
+    load_example.click(lambda: "1,2,3; 4,5,6; 7,8,9", None, groups_input)
+    # Shared input for both ANOVA and post-hoc
 
+    # -----------------------------------------
+    # SHARED COMPONENTS (define BEFORE tabs)
+    # -----------------------------------------
+    
+    # Shared input area
+
+    # ---------------------------------------------------
+    # Welch t-test
+    # ---------------------------------------------------
+    with gr.Tab("Welch t-test"):
+        with gr.Column():
+            gr.Markdown("### Compare two independent groups (unequal variances).")
+    
+            g1 = gr.Textbox(label="Group 1 (comma-separated numbers)")
+            g2 = gr.Textbox(label="Group 2 (comma-separated numbers)")
+            alt = gr.Radio(["two-sided", "less", "greater"], value="two-sided", label="Alternative hypothesis")
+    
+            run = gr.Button("Run Welch t-test", variant="primary")
+            out = gr.JSON(label="Results")
+    
+            download_welch = gr.DownloadButton("Download results")
+            #run.click(lambda *args: ui_welch(*args), inputs=[g1, g2, alt], outputs=[out])
+            run.click(ui_welch, inputs=[g1, g2, alt], outputs=out)
+    
+            run.click(
+                lambda r: save_json_to_file(r, "welch_results.json"),
+                inputs=[out],
+                outputs=[download_welch]
+            )
+    
+    
+    
+    
+            example_welch = "23,25,28,30,32", "18,20,22,25,27"
+            example_anova = "1,2,3; 2,3,4; 3,4,5"
+            
+            load_example = gr.Button("Load example")
+            load_example.click(
+                lambda: example_welch,
+                None,
+                [g1, g2]
+            )
+
+
+
+    # ---------------------------------------------------
+    # Student t-test
+    # ---------------------------------------------------
+    with gr.Tab("Student t-test"):
+        gr.Markdown("### Compare two independent groups (equal variances).")
+        with gr.Column():
+            g1_s = gr.Textbox(label="Group 1 (comma-separated numbers)")
+            g2_s = gr.Textbox(label="Group 2 (comma-separated numbers)")
+            alt_s = gr.Radio(["two-sided", "less", "greater"], value="two-sided", label="Alternative hypothesis")
+    
+            example_student = ("10,12,14,15,16", "9,11,13,14,15")
+            load_example_student = gr.Button("Load example")
+            load_example_student.click(lambda: example_student, None, [g1_s, g1_s])
+            run_s = gr.Button("Run Student t-test", variant="primary")
+            out_s = gr.JSON(label="Results")
+    
+            download_student = gr.DownloadButton("Download results")
+            run_s.click(ui_student, inputs=[g1_s, g1_s, alt_s], outputs=[out_s])
+            
+            run_s.click(
+                lambda r: save_json_to_file(r, "student_results.json"),
+                inputs=[out_s],
+                outputs=[download_student]
+            )
+    
+            #run.click(lambda *args: ui_welch(*args), inputs=[g1, g2, alt], outputs=[out])
+            #run.click(lambda r: ("results.json", json.dumps(r)), inputs=[out], outputs=[download])
+    
+    
+    
+    # ---------------------------------------------------
+    # Paired t-test
+    # ---------------------------------------------------
+    with gr.Tab("Paired t-test"):
+        gr.Markdown("### Compare two related measurements (same subjects).")
+        with gr.Column():
+            g1_p = gr.Textbox(label="Group 1 (comma-separated numbers)")
+            g2_p = gr.Textbox(label="Group 2 (comma-separated numbers)")
+            alt_p = gr.Radio(["two-sided", "less", "greater"], value="two-sided", label="Alternative hypothesis")
+    
+            example_paired = ("5,6,7,8,9", "6,7,8,9,10")
+            load_example_paired = gr.Button("Load example")
+            load_example_paired.click(lambda: example_paired, None, [g1_p, g2_p])
+            run_p = gr.Button("Run Paired t-test", variant="primary")
+            out_p = gr.JSON(label="Results")
+    
+            download_paired = gr.DownloadButton("Download results")
+            
+            run_p.click(ui_paired, inputs=[g1_p, g2_p, alt_p], outputs=[out_p])
+            
+            run_p.click(
+                lambda r: save_json_to_file(r, "paired_results.json"),
+                inputs=[out_p],
+                outputs=[download_paired]
+            )
+    
+            
+            #run.click(lambda *args: ui_welch(*args), inputs=[g1, g2, alt], outputs=[out])
+            #run.click(lambda r: ("results.json", json.dumps(r)), inputs=[out], outputs=[download])
+    
+            #run_p.click(ui_paired, inputs=[g1_p, g2_p, alt_p], outputs=out_p)
+
+
+    # ---------------------------------------------------
+    # One-sample t-test
+    # ---------------------------------------------------
+    with gr.Tab("One-sample t-test"):
+        with gr.Column():
+            g_os = gr.Textbox(label="Sample values (comma-separated)")
+            mu_os = gr.Number(label="Population mean", value=0)
+            alt_one = gr.Radio(["two-sided", "less", "greater"], value="two-sided")
+        
+            out_os = gr.JSON(label="Results")
+            run_os = gr.Button("Run One-sample t-test", variant="primary")
+            download_os = gr.DownloadButton("Download results")
+        
+            example_one_sample = "5,6,7,8,9"
+            load_example_one = gr.Button("Load example")
+            load_example_one.click(lambda: example_one_sample, None, [g_os])
+        
+            run_os.click(ui_os, inputs=[g_os, mu_os, alt_one], outputs=[out_os])
+        
+            run_os.click(
+                lambda r: save_json_to_file(r, "one_sample_results.json"),
+                inputs=[out_os],
+                outputs=[download_os]
+            )
+
+    # ---------------------------------------------------
+    # One-way ANOVA
+    # ---------------------------------------------------
 
-# -----------------------------
-# One-way ANOVA (multiple independent groups)
-# -----------------------------
-def one_way_anova(groups_str):
-    """
-    groups_str format:
-    "1,2,3; 4,5,6; 7,8,9"
-    """
-    groups = [np.array([float(x) for x in g.split(",")]) for g in groups_str.split(";")]
-
-    # Build DataFrame for Pingouin
-    import pandas as pd
-    data = []
-    for i, g in enumerate(groups):
-        for val in g:
-            data.append({"value": val, "group": f"G{i+1}"})
-
-    df = pd.DataFrame(data)
-
-    result = pg.anova(dv="value", between="group", data=df)
-    return pg_to_json(result)
+    
+    # -----------------------------------------
+    # ANOVA TAB
+    # -----------------------------------------
+    
+    with gr.Tab("ANOVA"):
+        with gr.Column():
+            run_anova = gr.Button("Run ANOVA")
+            out_anova = gr.JSON(label="Results")
+        
+            run_anova.click(ui_anova, inputs=[groups_input], outputs=[out_anova])
+    
+    # -----------------------------------------
+    # POST-HOC TAB
+    # -----------------------------------------
+    
+    with gr.Tab("Post-hoc"):
+        with gr.Column():
+            method = gr.Radio(["games-howell", "tukey"], value="games-howell")
+            run_post = gr.Button("Run post-hoc tests")
+            out_post = gr.JSON(label="Results")
+            download_post = gr.DownloadButton("Download results")
+        
+            run_post.click(lambda g, m: posthoc_tests(g, m),
+                           inputs=[groups_input, method],
+                           outputs=[out_post])
+        
+            run_post.click(lambda r: save_json_to_file(r, "posthoc.json"),
+                           inputs=[out_post],
+                           outputs=[download_post])
+
+    # ---------------------------------------------------
+    # Assumption Checks
+    # ---------------------------------------------------
+    with gr.Tab("Assumption Checks"):
+        with gr.Column():
+            gr.Markdown("### Normality & Homogeneity")
+            run_assump = gr.Button("Run assumption checks", variant="primary")
+            out_assump = gr.JSON(label="Results")
+            download_assump = gr.DownloadButton("Download results")
+    
+            # Use the shared groups_input
+            run_assump.click(
+                lambda g: assumption_checks(g),
+                inputs=[groups_input],
+                outputs=[out_assump]
+            )
+    
+            run_assump.click(
+                lambda r: save_json_to_file(r, "assumption_checks.json"),
+                inputs=[out_assump],
+                outputs=[download_assump]
+            )
+    
+    # ---------------------------------------------------
+    # Plots
+    # ---------------------------------------------------
+    with gr.Tab("Plot"):
+        with gr.Column():
+            run_plot = gr.Button("Generate Plot")
+            plot_output = gr.Image(type="pil", label="Plot")
+            download_plot = gr.DownloadButton("Download plot")
+        
+            run_plot.click(ui_plot, inputs=[groups_input], outputs=[plot_output])
+        
+            download_plot.click(
+                lambda img: save_png_to_file(img, "plot.png"),
+                inputs=[plot_output],
+                outputs=[download_plot]
+            )
+
+
+            
+
+# Main execution
+if __name__ == "__main__":
+    demo.launch(
+        theme=theme,
+        server_name="0.0.0.0",
+        server_port=7860
+    )