Create app.py

app.py

@@ -0,0 +1,447 @@
+import gradio as gr
+import matplotlib.pyplot as plt
+import numpy as np
+from io import BytesIO
+from PIL import Image
+
+# ---------- Transcript-authentic steps ----------
+STEPS = [
+    dict(
+        title="Step 1: Motor neuron → NMJ",
+        where=("A motor neuron goes directly from the spinal cord to the skeletal muscle. "
+               "The action potential travels down the axon to the axon terminal, calcium channels open, "
+               "and acetylcholine is released into the synapse."),
+        question="When the motor neuron releases acetylcholine, what happens next?",
+        options=[
+            "The muscle relaxes immediately.",
+            "Acetylcholine moves across the synapse and binds to receptors on the muscle cell membrane.",
+            "Calcium leaves the muscle fiber."
+        ],
+        correct=1,
+        visual="neuron"
+    ),
+    dict(
+        title="Step 2: Motor end plate (ligand-gated channels)",
+        where=("Acetylcholine moves to the motor end plate and binds nicotinic acetylcholine receptors. "
+               "These are ligand-gated channels that open when acetylcholine binds."),
+        question="When acetylcholine binds to its receptor at the motor end plate, which ion moves into the muscle cell?",
+        options=[
+            "Sodium moves into the cell.",
+            "Potassium moves into the cell.",
+            "Calcium leaves the sarcoplasmic reticulum."
+        ],
+        correct=0,
+        visual="nmj"
+    ),
+    dict(
+        title="Step 3: Threshold → action potential on sarcolemma",
+        where=("Sodium entry changes the voltage until threshold potential is reached. "
+               "Voltage-gated channels open and an action potential travels along the sarcolemma."),
+        question="What allows the electrical signal to travel quickly across the muscle cell membrane?",
+        options=[
+            "Voltage-gated sodium channels opening along the sarcolemma.",
+            "Continuous acetylcholine release.",
+            "ATP from mitochondria."
+        ],
+        correct=0,
+        visual="sarcolemma"
+    ),
+    dict(
+        title="Step 4: T-tubule voltage sensing (DHP)",
+        where=("The sarcolemma dives into the cell as the T-tubule. "
+               "When the action potential reaches this area, the DHP receptor senses the voltage change."),
+        question="When the DHP receptor senses the voltage change, what does it do?",
+        options=[
+            "It moves the ryanidine receptor so calcium can leave the sarcoplasmic reticulum.",
+            "It brings more sodium into the cell.",
+            "It breaks down ATP."
+        ],
+        correct=0,
+        visual="t_tubule"
+    ),
+    dict(
+        title="Step 5: Calcium leaves the SR",
+        where=("The ryanidine receptor opens. Calcium moves out of the sarcoplasmic reticulum into the cytoplasm "
+               "following a concentration gradient (high in SR → lower in cytoplasm)."),
+        question="Why does calcium move out of the sarcoplasmic reticulum?",
+        options=[
+            "There is a high concentration of calcium inside the SR and a lower concentration in the cytoplasm.",
+            "Calcium is pushed out by sodium.",
+            "It is actively pumped out using ATP."
+        ],
+        correct=0,
+        visual="sr_release"
+    ),
+    dict(
+        title="Step 6: Troponin → tropomyosin moves",
+        where=("Once calcium is in the sarcoplasm, it binds to troponin, which causes tropomyosin to move away "
+               "from the binding sites on actin."),
+        question="What is exposed when tropomyosin moves?",
+        options=[
+            "The myosin binding sites on actin.",
+            "The ATP-binding sites on myosin.",
+            "The calcium pumps on the sarcoplasmic reticulum."
+        ],
+        correct=0,
+        visual="thin_filament"
+    ),
+    dict(
+        title="Step 7: Cross-bridge cycling (ATP’s role)",
+        where=("Myosin binds to actin. ATP causes detachment; ATP hydrolysis re-cocks the myosin head. "
+               "Without ATP, myosin stays attached and the muscle is stiff."),
+        question="If there is no ATP available, what happens?",
+        options=[
+            "The myosin remains attached to actin, causing stiffness.",
+            "The muscle continues to contract rapidly.",
+            "The SR releases more calcium."
+        ],
+        correct=0,
+        visual="crossbridge"
+    ),
+    dict(
+        title="Step 8: Relaxation",
+        where=("When the excitatory signal stops, acetylcholine esterase breaks down acetylcholine. "
+               "Calcium is pumped back into the sarcoplasmic reticulum, and tropomyosin moves back over the binding sites."),
+        question="What two actions cause relaxation?",
+        options=[
+            "Acetylcholine breakdown and calcium re-uptake into the sarcoplasmic reticulum.",
+            "More acetylcholine release and ATP depletion.",
+            "Sodium leaving the muscle fiber."
+        ],
+        correct=0,
+        visual="relax"
+    ),
+]
+
+NODES = [
+    "ACh released at NMJ",
+    "ACh binds nicotinic receptor",
+    "Na⁺ entry → threshold → sarcolemma AP",
+    "T-tubule DHP senses voltage",
+    "RYR opens; Ca²⁺ leaves SR",
+    "Ca²⁺ binds troponin; tropomyosin moves",
+    "Cross-bridge cycling (ATP present)",
+    "Relaxation: AChE + SERCA"
+]
+
+EDGES = {
+    "ACh released at NMJ": ["ACh binds nicotinic receptor"],
+    "ACh binds nicotinic receptor": ["Na⁺ entry → threshold → sarcolemma AP"],
+    "Na⁺ entry → threshold → sarcolemma AP": ["T-tubule DHP senses voltage"],
+    "T-tubule DHP senses voltage": ["RYR opens; Ca²⁺ leaves SR"],
+    "RYR opens; Ca²⁺ leaves SR": ["Ca²⁺ binds troponin; tropomyosin moves"],
+    "Ca²⁺ binds troponin; tropomyosin moves": ["Cross-bridge cycling (ATP present)"],
+    "Cross-bridge cycling (ATP present)": ["Relaxation: AChE + SERCA"],
+    "Relaxation: AChE + SERCA": []
+}
+
+# ---------- visuals (return numpy arrays; robust on Spaces) ----------
+def draw_visual(kind: str) -> np.ndarray:
+    fig, ax = plt.subplots(figsize=(6, 3))
+    ax.axis("off")
+
+    def rect(x, y, w, h, fill=False): 
+        ax.add_patch(plt.Rectangle((x,y), w, h, fill=fill))
+    def arrow(x, y, dx, dy): 
+        ax.arrow(x, y, dx, dy, head_width=0.03, head_length=0.02, length_includes_head=True)
+    def circle(cx, cy, r): 
+        ax.add_patch(plt.Circle((cx, cy), r, fill=False))
+    def txt(x, y, t): 
+        ax.text(x, y, t, ha="center", va="center")
+
+    if kind == "neuron":
+        ax.text(0.05, 0.5, "Motor neuron → axon terminal (NMJ)\nACh released", ha="left", va="center")
+        arrow(0.35, 0.5, 0.45, 0)
+        circle(0.86, 0.5, 0.06)
+        txt(0.86, 0.5, "Terminal")
+    elif kind == "nmj":
+        rect(0.1, 0.35, 0.25, 0.3, fill=False)
+        txt(0.225, 0.66, "Presynaptic\nterminal")
+        txt(0.46, 0.50, "Synaptic cleft")
+        rect(0.62, 0.35, 0.28, 0.06, fill=True)
+        txt(0.76, 0.47, "Motor end plate\n(nicotinic AChR)")
+        arrow(0.35, 0.5, 0.22, 0)
+        txt(0.46, 0.56, "ACh →")
+    elif kind == "sarcolemma":
+        rect(0.1, 0.2, 0.8, 0.12, fill=True)
+        txt(0.5, 0.38, "Sarcolemma\n(voltage-gated Na⁺ open → AP)")
+    elif kind == "t_tubule":
+        rect(0.45, 0.1, 0.1, 0.8, fill=False)
+        txt(0.5, 0.93, "T-tubule")
+        rect(0.35, 0.1, 0.3, 0.1, fill=False)
+        txt(0.5, 0.06, "SR (RYR)")
+        txt(0.5, 0.5, "DHP senses voltage")
+    elif kind == "sr_release":
+        rect(0.2, 0.65, 0.6, 0.15, fill=False)
+        txt(0.5, 0.8, "SR: high [Ca²⁺]")
+        rect(0.2, 0.2, 0.6, 0.15, fill=False)
+        txt(0.5, 0.16, "Cytoplasm: lower [Ca²⁺]")
+        for x in [0.3, 0.45, 0.6]:
+            arrow(x, 0.65, 0, -0.25)
+        txt(0.5, 0.48, "Ca²⁺ follows concentration gradient")
+    elif kind == "thin_filament":
+        rect(0.1, 0.45, 0.8, 0.1, fill=True)
+        txt(0.5, 0.65, "Actin (thin filament)")
+        txt(0.5, 0.3, "Ca²⁺ binds troponin →\nTropomyosin moves")
+    elif kind == "crossbridge":
+        rect(0.1, 0.55, 0.8, 0.05, fill=True)
+        txt(0.5, 0.68, "Actin")
+        rect(0.1, 0.35, 0.8, 0.05, fill=True)
+        txt(0.5, 0.28, "Myosin")
+        txt(0.5, 0.47, "ATP binds → detachment\nATP hydrolysis → re-cock")
+    elif kind == "relax":
+        rect(0.2, 0.65, 0.6, 0.15, fill=False)
+        txt(0.5, 0.8, "SR")
+        rect(0.2, 0.2, 0.6, 0.15, fill=False)
+        for x in [0.3, 0.45, 0.6]:
+            arrow(x, 0.35, 0, 0.25)
+        txt(0.5, 0.55, "Ca²⁺ pumped back (ATP-dependent)")
+        txt(0.5, 0.12, "AChE breaks down acetylcholine")
+
+    buf = BytesIO()
+    plt.tight_layout()
+    fig.savefig(buf, format="png", bbox_inches="tight")
+    plt.close(fig)
+    buf.seek(0)
+    img = Image.open(buf).convert("RGB")
+    return np.array(img)
+
+# ---------- Step Trainer logic ----------
+def render_step(i:int):
+    i = int(i)
+    s = STEPS[i]
+    img = draw_visual(s["visual"])
+    return (f"### {s['title']}",
+            s["where"],
+            img,
+            f"**{s['question']}**",
+            gr.update(choices=s["options"], value=s["options"][0]),
+            "",  # feedback clear
+            i,   # state
+            i)   # progress
+
+def submit_step(i:int, picked:str):
+    i = int(i)
+    s = STEPS[i]
+    idx = s["options"].index(picked) if picked in s["options"] else -1
+    if idx == s["correct"]:
+        if i < len(STEPS)-1:
+            i += 1
+            fb = "✅ **Correct. Advancing…**"
+        else:
+            fb = "✅ **Done. Relaxation complete.**"
+    else:
+        i = 0
+        fb = "❌ **Incorrect. Returning to Step 1.**"
+    title, where, img, q, choices, _, _, _ = render_step(i)
+    return title, where, img, q, choices, fb, i, i
+
+def restart_step(_i:int):
+    title, where, img, q, choices, _, i, p = render_step(0)
+    return title, where, img, q, choices, "Restarted.", i, p
+
+# ---------- Failure-Point ----------
+def failure_check(fails, guess):
+    failed_idx = sorted([NODES.index(f) for f in (fails or [])]) if fails else []
+    lines = []
+    if failed_idx:
+        stop = failed_idx[0]
+        for j, lab in enumerate(NODES):
+            ok = j < stop
+            lines.append(("✅ " if ok else "⛔ ") + lab)
+            if not ok:
+                break
+        fb = "✅ **Correct: first failed step located.**" if (guess and NODES.index(guess)==stop) else "❌ **Not quite—identify the FIRST failed step.**"
+    else:
+        lines = ["✅ " + l for l in NODES]
+        lines.append("(No failures set — full propagation to relaxation.)")
+        fb = "No failures toggled."
+    return "```\n" + "\n".join(lines) + "\n```", fb
+
+# ---------- Sandbox ----------
+def sandbox_metrics(Na_out, Na_in, Ca_sr, Ca_cyto, ATP):
+    na_drive = max(0.0, (Na_out - Na_in) / max(1.0, Na_out))
+    ap_prob  = min(1.0, na_drive * 1.5)
+    dhp_ok   = ap_prob
+    ca_drive = max(0.0, (Ca_sr - Ca_cyto) / max(1.0, Ca_sr))
+    ca_rel   = dhp_ok * ca_drive
+    xbridges = min(1.0, ca_rel * (0.5 + 0.5*min(1.0, ATP)))
+    relax_ok = min(1.0, ATP) * 0.7 + (1.0 - ca_rel) * 0.3
+    return dict(ap_prob=ap_prob, ca_release=ca_rel, crossbridge=xbridges, relax_ok=relax_ok)
+
+def sandbox_plot(Na_out, Na_in, Ca_sr, Ca_cyto, ATP):
+    vals = sandbox_metrics(Na_out, Na_in, Ca_sr, Ca_cyto, ATP)
+    fig, ax = plt.subplots(figsize=(6,3))
+    keys = ["ap_prob","ca_release","crossbridge","relax_ok"]
+    ax.bar(keys, [vals[k] for k in keys])
+    ax.set_ylim(0,1)
+    ax.set_title("Predicted behaviors (0–1)")
+    buf = BytesIO(); fig.tight_layout(); fig.savefig(buf, format="png", bbox_inches="tight"); plt.close(fig)
+    buf.seek(0); img = Image.open(buf).convert("RGB")
+    return np.array(img)
+
+# ---------- Causality Builder ----------
+def chain_add(chain, pick):
+    import json
+    chain = json.loads(chain)
+    remaining = [n for n in NODES if n not in chain]
+    if not remaining:
+        return (gr.update(value=chain, interactive=False),
+                "Chain complete.",
+                gr.update(choices=[], interactive=False),
+                " → ".join(chain))
+    if pick is None:
+        return (gr.update(value=chain),
+                "Pick a next event.",
+                gr.update(),
+                " → ".join(chain))
+    ok = pick in EDGES.get(chain[-1], [])
+    if ok:
+        chain.append(pick)
+        remaining = [n for n in NODES if n not in chain]
+        msg = "✅ **Link accepted.**"
+    else:
+        msg = "❌ **That event doesn’t logically follow. Try a different next step.**"
+    return (gr.update(value=chain),
+            msg,
+            gr.update(choices=remaining, value=(remaining[0] if remaining else None), interactive=bool(remaining)),
+            " → ".join(chain))
+
+def chain_reset():
+    import json
+    chain = [NODES[0]]
+    remaining = [n for n in NODES if n not in chain]
+    return (gr.update(value=chain),
+            "Reset.",
+            gr.update(choices=remaining, value=remaining[0] if remaining else None, interactive=bool(remaining)),
+            " → ".join(chain))
+
+# ---------- Fatigue Lab ----------
+def simulate_fatigue(tmax=60, dt=0.5, atp_init=1.0, aerobic=0.3, anaerobic=0.2, load=0.5, serca_load=0.3):
+    n=int(tmax/dt)+1; t=np.linspace(0,tmax,n); atp=np.zeros(n); atp[0]=atp_init; rigor=np.zeros(n,dtype=bool)
+    for i in range(1,n):
+        cons = load*0.4 + serca_load*0.25
+        prod = aerobic*0.2 + anaerobic*0.15
+        atp[i] = np.clip(atp[i-1] + dt*(prod - cons), 0, 1.2)
+        rigor[i] = atp[i] < 0.1
+    fig, ax = plt.subplots(1,2, figsize=(8,3))
+    ax[0].plot(t, atp); ax[0].set_xlabel("time (s)"); ax[0].set_ylabel("ATP (a.u.)"); ax[0].set_title("ATP dynamics")
+    ax[1].bar(["rigor fraction"], [rigor.mean()]); ax[1].set_ylim(0,1); ax[1].set_title("Rigor")
+    buf = BytesIO(); fig.tight_layout(); fig.savefig(buf, format="png", bbox_inches="tight"); plt.close(fig)
+    buf.seek(0); img = Image.open(buf).convert("RGB")
+    msg = "Low ATP periods → stiffness (myosin remains attached)." if rigor.mean()>0 else "No stiffness expected (ATP maintained)."
+    return np.array(img), f"Estimated rigor fraction: {rigor.mean():.2f}\n{msg}"
+
+# ---------- Passport Analyzer ----------
+CORE_CONCEPTS = {
+  "Flow down gradients": ["gradient","concentration","moves from high to low","diffuse","diffusion"],
+  "Cell-to-cell communication": ["neurotransmitter","acetylcholine","receptor","synapse","binds"],
+  "Structure–function": ["structure","function","troponin","tropomyosin","binding site","receptor opens"],
+  "Energy flow": ["ATP","ADP","Pi","hydrolysis","energy"],
+  "Interdependence": ["depends","linked","together","if/then","cascade","pathway"]
+}
+def passport_analyze(text):
+    t = (text or "").lower()
+    counts = {k: sum(t.count(w) for w in ws) for k,ws in CORE_CONCEPTS.items()}
+    keys = list(counts.keys()); vals = [counts[k] for k in keys]
+    fig, ax = plt.subplots(figsize=(6,3)); ax.bar(keys, vals); ax.set_title("Core Concept mentions"); ax.tick_params(axis='x', rotation=30)
+    buf = BytesIO(); fig.tight_layout(); fig.savefig(buf, format="png", bbox_inches="tight"); plt.close(fig)
+    buf.seek(0); img = Image.open(buf).convert("RGB")
+    weak = [k for k in keys if counts[k]==0]
+    note = ("Consider adding explicit references to: " + ", ".join(weak)) if weak else "Balanced coverage detected."
+    import json
+    return np.array(img), json.dumps(counts, indent=2) + "\n\n" + note
+
+# ---------- Build UI ----------
+with gr.Blocks(title="EC Coupling Suite") as demo:
+    gr.Markdown("# EC Coupling Learning Suite (Transcript Language)")
+
+    with gr.Tabs():
+        # Step Trainer
+        with gr.Tab("Step Trainer"):
+            step_state = gr.State(0)
+            title = gr.Markdown()
+            where = gr.Markdown()
+            img = gr.Image(label="Where are we?")
+            q = gr.Markdown()
+            choice = gr.Radio(choices=[], label="Predict what happens next")
+            submit = gr.Button("Submit", variant="primary")
+            restart = gr.Button("Restart (Step 1)")
+            fb = gr.Markdown()
+            prog = gr.Slider(0, len(STEPS)-1, value=0, step=1, interactive=False, label="Progress")
+
+            # initialize on load (avoid setting .value directly)
+            demo.load(fn=lambda: render_step(0),
+                      inputs=None,
+                      outputs=[title, where, img, q, choice, fb, step_state, prog])
+
+            submit.click(submit_step, [step_state, choice], [title, where, img, q, choice, fb, step_state, prog])
+            restart.click(restart_step, [step_state], [title, where, img, q, choice, fb, step_state, prog])
+
+        # Failure-Point
+        with gr.Tab("Failure-Point"):
+            gr.Markdown("Toggle failures and diagnose the **first** failed step.")
+            fails = gr.CheckboxGroup(choices=NODES, label="Failures")
+            guess = gr.Dropdown(choices=NODES, label="Your diagnosis")
+            check = gr.Button("Test & Check", variant="primary")
+            log = gr.Markdown()
+            verdict = gr.Markdown()
+            check.click(failure_check, [fails, guess], [log, verdict])
+
+        # Sandbox
+        with gr.Tab("Sandbox"):
+            gr.Markdown("Adjust gradients and ATP; observe predicted behaviors (heuristic).")
+            Na_out = gr.Slider(10, 160, value=140, step=1, label='[Na⁺] outside')
+            Na_in  = gr.Slider(0, 50, value=15, step=1, label='[Na⁺] inside')
+            Ca_sr  = gr.Slider(0.1, 10.0, value=3.0, step=0.1, label='[Ca²⁺] SR')
+            Ca_c   = gr.Slider(0.0, 1.0, value=0.1, step=0.01, label='[Ca²⁺] cytoplasm')
+            ATP    = gr.Slider(0.0, 1.0, value=0.8, step=0.01, label='ATP (0–1)')
+            sb_img = gr.Image(label="Predicted bars")
+
+            for w in [Na_out, Na_in, Ca_sr, Ca_c, ATP]:
+                w.change(sandbox_plot, [Na_out, Na_in, Ca_sr, Ca_c, ATP], [sb_img])
+            sb_img.value = sandbox_plot(Na_out.value, Na_in.value, Ca_sr.value, Ca_c.value, ATP.value)
+
+        # Causality
+        with gr.Tab("Causality"):
+            gr.Markdown("Build a valid chain; logic is checked at each link.")
+            import json
+            chain_state = gr.State(json.dumps([NODES[0]]))
+            chain_text = gr.Markdown(" → ".join([NODES[0]]))
+            next_pick = gr.Dropdown(choices=[n for n in NODES if n != NODES[0]], label="Next event")
+            add = gr.Button("Add link", variant="primary")
+            reset = gr.Button("Reset")
+            fb2 = gr.Markdown()
+            add.click(chain_add, [chain_state, next_pick], [chain_state, fb2, next_pick, chain_text])
+            reset.click(chain_reset, [], [chain_state, fb2, next_pick, chain_text])
+
+        # Fatigue
+        with gr.Tab("Fatigue"):
+            gr.Markdown("Adjust ATP supply/demand; see ATP curve and rigor fraction.")
+            aerobic = gr.Slider(0,1,value=0.4,step=0.01,label="Aerobic supply")
+            anaer   = gr.Slider(0,1,value=0.3,step=0.01,label="Anaerobic supply")
+            work    = gr.Slider(0,1,value=0.6,step=0.01,label="Mechanical load")
+            serca   = gr.Slider(0,1,value=0.4,step=0.01,label="SERCA load")
+            dur     = gr.Slider(10,180,value=90,step=1,label="Duration (s)")
+            ftg_img = gr.Image(label="ATP & Rigor")
+            ftg_txt = gr.Markdown()
+
+            def ftg_update(dur_val, aer, anr, load, sl):
+                return simulate_fatigue(dur_val, 0.5, 1.0, aer, anr, load, sl)
+
+            for w in [aerobic, anaer, work, serca, dur]:
+                w.change(ftg_update, [dur, aerobic, anaer, work, serca], [ftg_img, ftg_txt])
+
+            img0, txt0 = simulate_fatigue(90, 0.5, 1.0, 0.4, 0.3, 0.6, 0.4)
+            ftg_img.value, ftg_txt.value = img0, txt0
+
+        # Passport
+        with gr.Tab("Passport"):
+            gr.Markdown("Paste your notes; see Core Concept emphasis.")
+            ta = gr.Textbox(lines=8, label="Notes / reflection")
+            pass_img = gr.Image(label="Concept counts")
+            pass_txt = gr.Markdown()
+            run = gr.Button("Analyze", variant="primary")
+            run.click(passport_analyze, [ta], [pass_img, pass_txt])
+
+demo.launch()