openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/iv_cmds.py

@@ -0,0 +1,106 @@
+"""Instrumental variable commands: ivregress."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.session import Session, ModelResult
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.dsl.parser import parse_formula, ParseError
+
+
+def _parse_iv_formula(raw: str) -> tuple[str, list[str], list[str], list[str]]:
+    """Parse IV formula: y ~ x1 (x_endog = z1 z2).
+
+    Returns (dep, exog_vars, endog_vars, instruments).
+    """
+    m = re.search(r'\((.+?)\)', raw)
+    if not m:
+        raise ParseError("IV formula requires parenthesized instruments: (endogenous = instruments)")
+
+    inner = m.group(1)
+    if '=' not in inner:
+        raise ParseError("Instrument block must use '=': (x_endog = z1 z2)")
+
+    endog_part, instr_part = inner.split('=', 1)
+    endog_vars = endog_part.split()
+    instruments = instr_part.split()
+
+    if not endog_vars:
+        raise ParseError("No endogenous variables specified")
+    if not instruments:
+        raise ParseError("No instruments specified")
+
+    # Remove parenthetical from args, parse remaining as formula
+    clean = raw[:m.start()] + raw[m.end():]
+    clean = clean.strip()
+    if '~' in clean:
+        dep, exog_vars = parse_formula(clean)
+    else:
+        parts = clean.split()
+        if not parts:
+            raise ParseError("No dependent variable specified")
+        dep = parts[0]
+        exog_vars = parts[1:] if len(parts) > 1 else []
+
+    return dep, exog_vars, endog_vars, instruments
+
+
+@command("ivregress", usage="ivregress 2sls y ~ x1 (x_endog = z1 z2) [--robust]")
+def cmd_ivregress(session: Session, args: str) -> str:
+    """Fit instrumental variable regression via Two-Stage Least Squares."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+
+    # First positional should be method (2sls)
+    if not ca.positional or ca.positional[0].lower() != "2sls":
+        return "Usage: ivregress 2sls y ~ x1 (x_endog = z1 z2) [--robust]"
+
+    robust = ca.has_flag("--robust")
+    formula_str = ca.strip_flags_and_options()
+    # Remove "2sls" prefix
+    formula_str = re.sub(r'^\s*2sls\s+', '', formula_str, flags=re.IGNORECASE).strip()
+
+    try:
+        dep, exog, endog, instruments = _parse_iv_formula(formula_str)
+    except ParseError as e:
+        return f"Formula error: {e}"
+
+    try:
+        from openstat.stats.iv import fit_iv_2sls
+
+        result, raw = fit_iv_2sls(df, dep, exog, endog, instruments, robust=robust)
+
+        # Store in session
+        session._last_model = raw
+        session._last_model_vars = (dep, exog + endog)
+        session._last_fit_result = result
+        session._last_fit_kwargs = {"method": "2sls", "endog": endog, "instruments": instruments}
+
+        all_vars = result.indep_vars
+        md = result.to_markdown() if hasattr(result, "to_markdown") else ""
+        session.results.append(ModelResult(
+            name="IV-2SLS", formula=result.formula,
+            table=md, details={
+                "n_obs": result.n_obs,
+                "params": dict(result.params),
+                "r_squared": result.r_squared,
+            },
+        ))
+
+        output = result.summary_table()
+        if result.warnings:
+            output += "\n" + "\n".join(result.warnings)
+
+        # Auto-show first-stage diagnostics
+        try:
+            from openstat.stats.iv import first_stage_diagnostics
+            output += "\n\n" + first_stage_diagnostics(raw)
+        except Exception:
+            pass
+
+        return output
+    except ImportError as e:
+        return str(e)
+    except Exception as e:
+        return friendly_error(e, "ivregress")

openstat/commands/manova_cmds.py

@@ -0,0 +1,105 @@
+"""MANOVA and two-way ANOVA commands."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str], set[str]]:
+    opts: dict[str, str] = {}
+    flags: set[str] = set()
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = []
+    for tok in rest.split():
+        tok = tok.strip(',')
+        if not tok:
+            continue
+        if tok.startswith('--'):
+            flags.add(tok.lstrip('-').lower())
+        elif tok:
+            positional.append(tok)
+    return positional, opts, flags
+
+
+@command("anova2", usage="anova2 depvar factor1 factor2 [, --nointeraction]")
+def cmd_anova2(session: Session, args: str) -> str:
+    """Two-way ANOVA with optional interaction term."""
+    df = session.require_data()
+    positional, opts, flags = _stata_opts(args)
+    if len(positional) < 3:
+        return "Usage: anova2 depvar factor1 factor2 [, --nointeraction]"
+
+    dep = positional[0]
+    f1 = positional[1]
+    f2 = positional[2]
+    interaction = "nointeraction" not in flags
+
+    try:
+        from openstat.stats.manova import twoway_anova
+        result = twoway_anova(df, dep, f1, f2, interaction=interaction)
+    except Exception as exc:
+        return f"anova2 error: {exc}"
+
+    lines = [f"\nTwo-way ANOVA: {dep} ~ {f1} + {f2}", "=" * 70]
+    lines.append(
+        f"  {'Source':<35}  {'df':>4}  {'SS':>12}  {'MS':>12}  {'F':>8}  {'p-value':>8}"
+    )
+    lines.append("  " + "-" * 66)
+    for row in result["table"]:
+        src = row["source"][:35]
+        f_str = f"{row['F']:>8.3f}" if not (row["F"] != row["F"]) else "      ."
+        p_str = f"{row['p_value']:>8.4f}" if not (row["p_value"] != row["p_value"]) else "      ."
+        ss = row["SS"] if row["SS"] == row["SS"] else float("nan")
+        ms = row["MS"] if row["MS"] == row["MS"] else float("nan")
+        ss_s = f"{ss:>12.4f}" if ss == ss else f"{'':>12}"
+        ms_s = f"{ms:>12.4f}" if ms == ms else f"{'':>12}"
+        lines.append(f"  {src:<35}  {row['df']:>4}  {ss_s}  {ms_s}  {f_str}  {p_str}")
+    lines.append("=" * 70)
+    lines.append(f"  R² = {result['r_squared']:.4f}   N = {result['n_obs']}")
+    return "\n".join(lines)
+
+
+@command("manova", usage="manova depvar1 depvar2 ... = groupvar")
+def cmd_manova(session: Session, args: str) -> str:
+    """One-way MANOVA: test group differences on multiple outcomes."""
+    df = session.require_data()
+    # parse: "y1 y2 y3 = groupvar"
+    if "=" not in args:
+        return "Usage: manova depvar1 depvar2 ... = groupvar"
+
+    parts = args.split("=", 1)
+    dep_vars = [c.strip() for c in parts[0].split() if c.strip() in df.columns]
+    group = parts[1].strip()
+
+    if not dep_vars:
+        return "No valid dependent variables found."
+    if group not in df.columns:
+        return f"Group variable '{group}' not found."
+
+    try:
+        from openstat.stats.manova import fit_manova
+        result = fit_manova(df, dep_vars, group)
+    except Exception as exc:
+        return f"manova error: {exc}"
+
+    lines = [
+        f"\nMANOVA: {', '.join(dep_vars)} ~ {group}",
+        f"  N = {result['n_obs']}, Groups = {result['n_groups']}",
+        "=" * 75,
+        f"  {'Effect':<20}  {'Test':<20}  {'Stat':>8}  {'F':>8}  {'Num df':>6}  {'Den df':>6}  {'p':>8}",
+        "  " + "-" * 71,
+    ]
+    for eff in result["effects"]:
+        p_str = f"{eff['p_value']:>8.4f}" if eff['p_value'] == eff['p_value'] else "      ."
+        lines.append(
+            f"  {eff['effect'][:20]:<20}  {eff['test'][:20]:<20}"
+            f"  {eff['statistic']:>8.4f}  {eff['F']:>8.3f}"
+            f"  {eff['num_df']:>6.1f}  {eff['den_df']:>6.1f}  {p_str}"
+        )
+    lines.append("=" * 75)
+    return "\n".join(lines)

openstat/commands/mediate_cmds.py

@@ -0,0 +1,233 @@
+"""Mediation and moderated-mediation analysis commands."""
+
+from __future__ import annotations
+
+import numpy as np
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+def _bootstrap_indirect(x, m, y, n_boot: int = 1000, seed: int | None = None):
+    """Return bootstrap distribution of indirect effect a*b."""
+    rng = np.random.default_rng(seed)
+    n = len(x)
+    ab_boots = []
+    for _ in range(n_boot):
+        idx = rng.integers(0, n, size=n)
+        xb, mb, yb = x[idx], m[idx], y[idx]
+        # a path: m ~ x
+        xb_ = np.column_stack([np.ones(n), xb])
+        try:
+            a = np.linalg.lstsq(xb_, mb, rcond=None)[0][1]
+            # b path: y ~ x + m
+            xmb = np.column_stack([np.ones(n), xb, mb])
+            b = np.linalg.lstsq(xmb, yb, rcond=None)[0][2]
+            ab_boots.append(a * b)
+        except Exception:
+            continue
+    return np.array(ab_boots)
+
+
+@command("mediate", usage="mediate <y> <m> <x> [--boot=1000] [--seed=N]")
+def cmd_mediate(session: Session, args: str) -> str:
+    """Baron-Kenny mediation analysis with bootstrap CI for indirect effect.
+
+    Tests whether m mediates the effect of x on y.
+
+    Paths:
+      a: x → m
+      b: m → y (controlling x)
+      c: x → y (total)
+      c': x → y (direct, controlling m)
+      indirect = a × b
+
+    Examples:
+      mediate income educ age
+      mediate y mediator x --boot=5000 --seed=42
+    """
+    import polars as pl
+    ca = CommandArgs(args)
+    if len(ca.positional) < 3:
+        return "Usage: mediate <y> <m> <x> [--boot=1000] [--seed=N]"
+
+    y_col, m_col, x_col = ca.positional[0], ca.positional[1], ca.positional[2]
+    n_boot = int(ca.options.get("boot", 1000))
+    seed = int(ca.options["seed"]) if "seed" in ca.options else getattr(session, "_repro_seed", None)
+
+    try:
+        df = session.require_data()
+        sub = df.select([y_col, m_col, x_col]).drop_nulls()
+        if sub.height < 10:
+            return "Need at least 10 complete cases."
+
+        y = sub[y_col].to_numpy().astype(float)
+        m = sub[m_col].to_numpy().astype(float)
+        x = sub[x_col].to_numpy().astype(float)
+        n = len(y)
+        ones = np.ones(n)
+
+        def ols(X, y_):
+            coef, _, _, _ = np.linalg.lstsq(X, y_, rcond=None)
+            y_hat = X @ coef
+            resid = y_ - y_hat
+            sigma2 = np.dot(resid, resid) / max(n - X.shape[1], 1)
+            cov = sigma2 * np.linalg.pinv(X.T @ X)
+            se = np.sqrt(np.diag(cov))
+            return coef, se
+
+        # a path: m ~ x
+        Xa = np.column_stack([ones, x])
+        a_coef, a_se = ols(Xa, m)
+        a, se_a = a_coef[1], a_se[1]
+
+        # b & c' paths: y ~ x + m
+        Xbc = np.column_stack([ones, x, m])
+        bc_coef, bc_se = ols(Xbc, y)
+        c_prime, se_cp = bc_coef[1], bc_se[1]
+        b, se_b = bc_coef[2], bc_se[2]
+
+        # c path: y ~ x (total)
+        Xc = np.column_stack([ones, x])
+        c_coef, c_se = ols(Xc, y)
+        c, se_c = c_coef[1], c_se[1]
+
+        indirect = a * b
+
+        # Bootstrap CI for indirect
+        ab_dist = _bootstrap_indirect(x, m, y, n_boot=n_boot, seed=seed)
+        ci_lo = float(np.percentile(ab_dist, 2.5))
+        ci_hi = float(np.percentile(ab_dist, 97.5))
+
+        # z-stats (paths a, b, c, c')
+        from scipy import stats as _st
+        def _p(coef, se): return 2 * _st.t.sf(abs(coef / se), df=n - 2) if se > 0 else float("nan")
+
+        mediated_pct = 100 * abs(indirect / c) if abs(c) > 1e-12 else float("nan")
+
+        lines = [
+            f"Mediation Analysis: {y_col} ~ {x_col} → {m_col} → {y_col}",
+            f"N = {n}",
+            "=" * 56,
+            f"  {'Path':<20} {'Coef':>9} {'SE':>9} {'p':>9}",
+            "-" * 56,
+            f"  {'a  (x->m)':<20} {a:9.4f} {se_a:9.4f} {_p(a,se_a):9.4f}",
+            f"  {'b  (m->y|x)':<20} {b:9.4f} {se_b:9.4f} {_p(b,se_b):9.4f}",
+            f"  {'c  total (x->y)':<20} {c:9.4f} {se_c:9.4f} {_p(c,se_c):9.4f}",
+            "  {:<20} {:9.4f} {:9.4f} {:9.4f}".format("c' direct(x->y|m)", c_prime, se_cp, _p(c_prime, se_cp)),
+            "=" * 56,
+            f"  Indirect (a×b):     {indirect:9.4f}",
+            f"  Bootstrap 95% CI:   [{ci_lo:.4f}, {ci_hi:.4f}]  (B={n_boot})",
+            f"  % Mediated:         {mediated_pct:.1f}%" if not np.isnan(mediated_pct) else "  % Mediated:         N/A",
+            "",
+            "Mediation: " + ("YES — CI excludes 0" if ci_lo * ci_hi > 0 else "NOT significant (CI includes 0)"),
+        ]
+        return "\n".join(lines)
+
+    except Exception as e:
+        return friendly_error(e, "mediate")
+
+
+@command("modmediate", usage="modmediate <y> <m> <x> <w> [--boot=1000]")
+def cmd_modmediate(session: Session, args: str) -> str:
+    """Moderated mediation (Hayes PROCESS Model 7 style).
+
+    Tests whether the indirect effect of x on y through m
+    is moderated by w (moderator of the a-path: x->m).
+
+    Index of Moderated Mediation (IMM) with bootstrap CI.
+
+    Examples:
+      modmediate outcome mediator predictor moderator --boot=2000
+    """
+    import polars as pl
+    ca = CommandArgs(args)
+    if len(ca.positional) < 4:
+        return "Usage: modmediate <y> <m> <x> <w> [--boot=1000] [--seed=N]"
+
+    y_col, m_col, x_col, w_col = (ca.positional[i] for i in range(4))
+    n_boot = int(ca.options.get("boot", 1000))
+    seed = int(ca.options["seed"]) if "seed" in ca.options else getattr(session, "_repro_seed", None)
+
+    try:
+        df = session.require_data()
+        sub = df.select([y_col, m_col, x_col, w_col]).drop_nulls()
+        if sub.height < 20:
+            return "Need at least 20 complete cases."
+
+        y = sub[y_col].to_numpy().astype(float)
+        m = sub[m_col].to_numpy().astype(float)
+        x = sub[x_col].to_numpy().astype(float)
+        w = sub[w_col].to_numpy().astype(float)
+        n = len(y)
+        ones = np.ones(n)
+
+        # Standardise w for interaction
+        w_c = w - w.mean()
+        xw = x * w_c
+
+        def ols(X, y_):
+            coef, _, _, _ = np.linalg.lstsq(X, y_, rcond=None)
+            return coef
+
+        # a-path moderated: m ~ x + w + x*w
+        Xa = np.column_stack([ones, x, w_c, xw])
+        a_coef = ols(Xa, m)
+        a1, a3 = a_coef[1], a_coef[3]  # a1=x coef, a3=interaction
+
+        # b-path: y ~ x + m
+        Xb = np.column_stack([ones, x, m])
+        b_coef = ols(Xb, y)
+        b = b_coef[2]
+
+        # Conditional indirect at w = mean ± 1SD
+        w_sd = w_c.std()
+        w_vals = {"Low (−1SD)": -w_sd, "Mean": 0.0, "High (+1SD)": w_sd}
+
+        def _boot_imm(rng):
+            idx = rng.integers(0, n, size=n)
+            xb, mb, yb, wb = x[idx], m[idx], y[idx], w_c[idx]
+            xwb = xb * wb
+            Xab = np.column_stack([np.ones(n), xb, wb, xwb])
+            try:
+                ac = ols(Xab, mb)
+                Xbb = np.column_stack([np.ones(n), xb, mb])
+                bc = ols(Xbb, yb)
+                return ac[3] * bc[2]  # IMM = a3 * b
+            except Exception:
+                return np.nan
+
+        rng = np.random.default_rng(seed)
+        imm_boots = np.array([_boot_imm(rng) for _ in range(n_boot)])
+        imm_boots = imm_boots[~np.isnan(imm_boots)]
+        imm = a3 * b
+        ci_lo = float(np.percentile(imm_boots, 2.5))
+        ci_hi = float(np.percentile(imm_boots, 97.5))
+
+        lines = [
+            f"Moderated Mediation: {y_col} ~ {x_col}→{m_col}→{y_col}, moderated by {w_col}",
+            f"N = {n}",
+            "=" * 60,
+            "Conditional Indirect Effects (a×b at levels of moderator):",
+            f"  {'Level':<15} {'a+a3*w':>10} {'Indirect':>10}",
+            "-" * 60,
+        ]
+        for label, wv in w_vals.items():
+            cond_a = a1 + a3 * wv
+            indirect = cond_a * b
+            lines.append(f"  {label:<15} {cond_a:10.4f} {indirect:10.4f}")
+
+        lines += [
+            "=" * 60,
+            f"  Index of Moderated Mediation (a3×b): {imm:.4f}",
+            f"  Bootstrap 95% CI: [{ci_lo:.4f}, {ci_hi:.4f}]  (B={n_boot})",
+            "",
+            "Moderated mediation: " + (
+                "YES — IMM CI excludes 0" if ci_lo * ci_hi > 0
+                else "NOT significant (CI includes 0)"
+            ),
+        ]
+        return "\n".join(lines)
+
+    except Exception as e:
+        return friendly_error(e, "modmediate")