openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/dsl_cmds.py

@@ -0,0 +1,143 @@
+"""DSL commands: local, global, forval, foreach, assert, display."""
+
+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]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+@command("local", usage="local name value")
+def cmd_local(session: Session, args: str) -> str:
+    """Define a local macro variable."""
+    parts = args.strip().split(None, 1)
+    if len(parts) < 2:
+        return "Usage: local name value"
+    name, value = parts[0], parts[1]
+    if not hasattr(session, "_locals"):
+        session._locals = {}
+    session._locals[name] = value
+    return f"local `{name}' = {value}"
+
+
+@command("global", usage="global name value")
+def cmd_global(session: Session, args: str) -> str:
+    """Define a global macro variable."""
+    parts = args.strip().split(None, 1)
+    if len(parts) < 2:
+        return "Usage: global name value"
+    name, value = parts[0], parts[1]
+    if not hasattr(session, "_globals"):
+        session._globals = {}
+    session._globals[name] = value
+    return f"global ${name} = {value}"
+
+
+@command("display", usage="display expression_or_text")
+def cmd_display(session: Session, args: str) -> str:
+    """Display text or evaluate a simple numeric expression."""
+    text = args.strip().strip('"').strip("'")
+    # Substitute local macros `name'
+    if hasattr(session, "_locals"):
+        for k, v in session._locals.items():
+            text = text.replace(f"`{k}'", v)
+    # Substitute global macros $name
+    if hasattr(session, "_globals"):
+        for k, v in session._globals.items():
+            text = text.replace(f"${k}", v)
+    # Try simple arithmetic evaluation
+    try:
+        result = eval(text, {"__builtins__": {}})  # noqa: S307
+        return str(result)
+    except Exception:
+        return text
+
+
+@command("assert", usage="assert condition_description [var op value]")
+def cmd_assert(session: Session, args: str) -> str:
+    """Assert that a condition holds in the data. Returns pass/fail."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    # Simple form: assert var op value (e.g., assert age > 0)
+    # Use polars expression
+    expr_str = args.strip()
+    # Try to parse var op value
+    m = re.match(r'(\w+)\s*(==|!=|>=|<=|>|<)\s*(.+)', expr_str)
+    if not m:
+        return f"assert syntax: varname op value (e.g., assert age > 0)"
+    var, op, val_str = m.group(1), m.group(2), m.group(3).strip()
+    if var not in df.columns:
+        return f"Column '{var}' not found."
+    try:
+        val = float(val_str)
+        import polars as pl
+        ops = {"==": pl.col(var) == val, "!=": pl.col(var) != val,
+               ">": pl.col(var) > val, "<": pl.col(var) < val,
+               ">=": pl.col(var) >= val, "<=": pl.col(var) <= val}
+        mask = ops[op]
+        n_fail = int(df.filter(~mask).height)
+        if n_fail == 0:
+            return f"Assertion passed: {var} {op} {val} holds for all {df.height} observations."
+        else:
+            return f"Assertion FAILED: {n_fail} of {df.height} observations violate {var} {op} {val}."
+    except Exception as exc:
+        return f"assert error: {exc}"
+
+
+@command("forval", usage="forval i=start/end : command args")
+def cmd_forval(session: Session, args: str) -> str:
+    """Execute a command for each value in a range. forval i=1/5 : display `i'"""
+    m = re.match(r'(\w+)\s*=\s*(\d+)\s*/\s*(\d+)\s*:\s*(.+)', args.strip())
+    if not m:
+        return "Usage: forval i=start/end : command args"
+    var, start, end, cmd_str = m.group(1), int(m.group(2)), int(m.group(3)), m.group(4).strip()
+    from openstat.commands.base import run_command
+    outputs = []
+    for i in range(start, end + 1):
+        if not hasattr(session, "_locals"):
+            session._locals = {}
+        session._locals[var] = str(i)
+        expanded = cmd_str.replace(f"`{var}'", str(i))
+        try:
+            out = run_command(session, expanded)
+            if out:
+                outputs.append(out)
+        except Exception as exc:
+            outputs.append(f"forval error at i={i}: {exc}")
+            break
+    return "\n".join(outputs) if outputs else f"forval completed {end - start + 1} iterations."
+
+
+@command("foreach", usage="foreach var in list : command")
+def cmd_foreach(session: Session, args: str) -> str:
+    """Execute a command for each item in a list."""
+    m = re.match(r'(\w+)\s+in\s+(.+?)\s*:\s*(.+)', args.strip())
+    if not m:
+        return "Usage: foreach var in item1 item2 ... : command"
+    var, items_str, cmd_str = m.group(1), m.group(2).strip(), m.group(3).strip()
+    items = items_str.split()
+    from openstat.commands.base import run_command
+    outputs = []
+    for item in items:
+        if not hasattr(session, "_locals"):
+            session._locals = {}
+        session._locals[var] = item
+        expanded = cmd_str.replace(f"`{var}'", item)
+        try:
+            out = run_command(session, expanded)
+            if out:
+                outputs.append(out)
+        except Exception as exc:
+            outputs.append(f"foreach error at {var}={item}: {exc}")
+            break
+    return "\n".join(outputs) if outputs else f"foreach completed {len(items)} iterations."

openstat/commands/epi_cmds.py

@@ -0,0 +1,93 @@
+"""Epidemiology commands: cs (cohort study), cc (case-control), ir (incidence rate)."""
+
+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]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+def _fmt_epi(r: dict) -> str:
+    lines = [f"\n{r.get('test', 'Result')}", "=" * 50]
+    skip = {"test", "table_2x2", "_model"}
+    for k, v in r.items():
+        if k in skip:
+            continue
+        if isinstance(v, float):
+            lines.append(f"  {k:<30} {v:.4f}")
+        else:
+            lines.append(f"  {k:<30} {v}")
+    t = r.get("table_2x2")
+    if t:
+        lines.append("\n  2x2 Table:")
+        lines.append(f"  {'':15} Exposed  Unexposed")
+        lines.append(f"  {'Cases':15} {t['a']:>8}  {t['b']:>8}")
+        lines.append(f"  {'Non-cases':15} {t['c']:>8}  {t['d']:>8}")
+    return "\n".join(lines)
+
+
+@command("cs", usage="cs outcome exposure")
+def cmd_cs(session: Session, args: str) -> str:
+    """Cohort study analysis: risk ratio, ARR, NNT."""
+    from openstat.stats.epidemiology import cohort_study
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: cs outcome exposure"
+    outcome, exposure = positional[0], positional[1]
+    for v in (outcome, exposure):
+        if v not in df.columns:
+            return f"Column '{v}' not found."
+    try:
+        r = cohort_study(df, outcome, exposure)
+        return _fmt_epi(r)
+    except Exception as exc:
+        return f"cs error: {exc}"
+
+
+@command("cc", usage="cc outcome exposure")
+def cmd_cc(session: Session, args: str) -> str:
+    """Case-control analysis: odds ratio with 95% CI."""
+    from openstat.stats.epidemiology import case_control
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: cc outcome exposure"
+    outcome, exposure = positional[0], positional[1]
+    for v in (outcome, exposure):
+        if v not in df.columns:
+            return f"Column '{v}' not found."
+    try:
+        r = case_control(df, outcome, exposure)
+        return _fmt_epi(r)
+    except Exception as exc:
+        return f"cc error: {exc}"
+
+
+@command("ir", usage="ir outcome person_time_var")
+def cmd_ir(session: Session, args: str) -> str:
+    """Incidence rate analysis."""
+    from openstat.stats.epidemiology import incidence_rate
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: ir outcome person_time_var"
+    outcome, pt_var = positional[0], positional[1]
+    for v in (outcome, pt_var):
+        if v not in df.columns:
+            return f"Column '{v}' not found."
+    try:
+        r = incidence_rate(df, outcome, pt_var)
+        return _fmt_epi(r)
+    except Exception as exc:
+        return f"ir error: {exc}"

openstat/commands/equiv_tobit_cmds.py

@@ -0,0 +1,94 @@
+"""Equivalence test and Tobit 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]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+def _fmt(r: dict) -> str:
+    lines = [f"\n{r.get('test', 'Result')}", "=" * 55]
+    skip = {"test", "groups", "_model"}
+    for k, v in r.items():
+        if k in skip:
+            continue
+        if isinstance(v, float):
+            lines.append(f"  {k:<35} {v:.6f}")
+        elif isinstance(v, list):
+            lines.append(f"  {k:<35} {v}")
+        else:
+            lines.append(f"  {k:<35} {v}")
+    lines.append("=" * 55)
+    return "\n".join(lines)
+
+
+@command("tost", usage="tost var [by(group)] [mu(0) delta(0.5) alpha(0.05)]")
+def cmd_tost(session: Session, args: str) -> str:
+    """Two One-Sided Tests (TOST) for equivalence."""
+    from openstat.stats.equiv_tobit import tost_onemean, tost_twomeans
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if not positional:
+        return "Usage: tost var [by(group)] [mu(0) delta(0.5) alpha(0.05)]"
+    col = positional[0]
+    if col not in df.columns:
+        return f"Column '{col}' not found."
+    by = opts.get("by")
+    delta = float(opts.get("delta", 0.5))
+    alpha = float(opts.get("alpha", 0.05))
+    try:
+        if by:
+            if by not in df.columns:
+                return f"Group column '{by}' not found."
+            r = tost_twomeans(df, col, by, delta=delta, alpha=alpha)
+        else:
+            mu = float(opts.get("mu", 0.0))
+            r = tost_onemean(df, col, mu=mu, delta=delta, alpha=alpha)
+        return _fmt(r)
+    except Exception as exc:
+        return f"tost error: {exc}"
+
+
+@command("tobit", usage="tobit dep var1 var2 ... [ll(0) ul(none)]")
+def cmd_tobit(session: Session, args: str) -> str:
+    """Tobit regression for censored outcomes."""
+    from openstat.stats.equiv_tobit import fit_tobit
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: tobit dep var1 [var2 ...] [ll(0) ul(none)]"
+    dep = positional[0]
+    indeps = [c for c in positional[1:] if c in df.columns]
+    if dep not in df.columns:
+        return f"Column '{dep}' not found."
+    left = float(opts["ll"]) if "ll" in opts else 0.0
+    right = float(opts["ul"]) if "ul" in opts else None
+    try:
+        r = fit_tobit(df, dep, indeps, left=left, right=right)
+        session._last_model = r
+        lines = ["\nTobit Regression", "=" * 55]
+        lines.append(f"  {'Dep. Variable':<30} {dep}")
+        lines.append(f"  {'N obs':<30} {r['n_obs']}")
+        lines.append(f"  {'Left censoring':<30} {r['left_censoring']} (n={r['n_censored_left']})")
+        lines.append(f"  {'Right censoring':<30} {r['right_censoring']} (n={r['n_censored_right']})")
+        lines.append(f"  {'Log-likelihood':<30} {r['log_likelihood']:.4f}")
+        lines.append(f"  {'AIC':<30} {r['aic']:.4f}")
+        lines.append(f"  {'Sigma':<30} {r['sigma']:.4f}")
+        lines.append(f"\n  {'Variable':<25} {'Coef':>10}")
+        lines.append("  " + "-" * 37)
+        for nm, coef in r["params"].items():
+            lines.append(f"  {nm:<25} {coef:>10.4f}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"tobit error: {exc}"

openstat/commands/esttab_cmds.py

@@ -0,0 +1,196 @@
+"""esttab and tabstat commands for multi-model comparison tables."""
+
+from __future__ import annotations
+
+import re
+
+import polars as pl
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+@command("esttab", usage="esttab [stats(coef,se,pval)] [stars]")
+def cmd_esttab(session: Session, args: str) -> str:
+    """Display a publication-style comparison table of all stored regression results."""
+    positional, opts = _stata_opts(args)
+    stats_req = opts.get("stats", "coef,se").split(",")
+    show_stars = "stars" in args
+
+    raw_results = session.results
+    if not raw_results:
+        return "No stored results. Run regression commands first."
+
+    # Normalize: ModelResult objects → dict via .details
+    results = []
+    for res in raw_results:
+        if isinstance(res, dict):
+            results.append(res)
+        elif hasattr(res, "details"):
+            results.append(res.details)
+
+    # Collect all parameter names across models
+    all_params: list[str] = []
+    for res in results:
+        if "params" in res:
+            for p in res["params"]:
+                if p not in all_params:
+                    all_params.append(p)
+        elif "coefficients" in res:
+            for p in res["coefficients"]:
+                if p not in all_params:
+                    all_params.append(p)
+
+    if not all_params:
+        return "No regression results with coefficients found."
+
+    col_w = 14
+
+    def _get_coef(res, param):
+        if "coefficients" in res:
+            c = res["coefficients"].get(param, {})
+            return c.get("mean", float("nan"))
+        if "params" in res:
+            return res["params"].get(param, float("nan"))
+        return float("nan")
+
+    def _get_se(res, param):
+        if "coefficients" in res:
+            c = res["coefficients"].get(param, {})
+            return c.get("std", float("nan"))
+        if "std_errors" in res:
+            return res["std_errors"].get(param, float("nan"))
+        return float("nan")
+
+    def _get_pval(res, param):
+        if "p_values" in res:
+            return res["p_values"].get(param, float("nan"))
+        if "coefficients" in res:
+            c = res["coefficients"].get(param, {})
+            return c.get("prob_positive", float("nan"))
+        return float("nan")
+
+    def _stars(p):
+        if p != p: return ""
+        if p < 0.001: return "***"
+        if p < 0.01: return "**"
+        if p < 0.05: return "*"
+        return ""
+
+    model_list = [r for r in results if "params" in r or "coefficients" in r]
+    header = f"{'':25}" + "".join(f"  {'('+str(i+1)+')':>{col_w}}" for i in range(len(model_list)))
+    sep = "-" * (25 + (col_w + 2) * len(model_list))
+    lines = ["\nesttab — Regression Comparison", sep, header, sep]
+
+    for param in all_params:
+        coef_row = f"{param:<25}"
+        se_row = f"{'':25}"
+        for res in model_list:
+            coef = _get_coef(res, param)
+            se = _get_se(res, param)
+            pval = _get_pval(res, param)
+            stars = _stars(pval) if show_stars else ""
+            if coef != coef:
+                coef_row += f"  {'':>{col_w}}"
+                se_row += f"  {'':>{col_w}}"
+            else:
+                coef_str = f"{coef:.4f}{stars}"
+                coef_row += f"  {coef_str:>{col_w}}"
+                se_str = f"({se:.4f})" if se == se else ""
+                se_row += f"  {se_str:>{col_w}}"
+        lines.append(coef_row)
+        if "se" in stats_req:
+            lines.append(se_row)
+
+    lines.append(sep)
+    # Model-level stats
+    n_row = f"{'N':25}"
+    r2_row = f"{'R-squared':25}"
+    for res in model_list:
+        n = res.get("n_obs", "")
+        r2 = res.get("r_squared", res.get("pseudo_r2", ""))
+        n_row += f"  {str(n):>{col_w}}"
+        r2_row += f"  {(f'{r2:.4f}' if isinstance(r2, float) else ''):>{col_w}}"
+    lines.append(n_row)
+    lines.append(r2_row)
+    lines.append(sep)
+    if show_stars:
+        lines.append("* p<0.05  ** p<0.01  *** p<0.001")
+    return "\n".join(lines)
+
+
+@command("tabstat", usage="tabstat var1 [var2 ...] [, stats(mean sd min max n) by(groupvar)]")
+def cmd_tabstat(session: Session, args: str) -> str:
+    """Display summary statistics table (enhanced version of summarize)."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    cols = [c for c in positional if c in df.columns]
+    if not cols:
+        return "No valid numeric variables found."
+    stats_req = [s.strip() for s in opts.get("stats", "mean,sd,min,max,n").split(",")]
+    by_raw = opts.get("by", "")
+    by_var = by_raw.strip() if by_raw.strip() in df.columns else None
+
+    def _compute_stats(series: pl.Series, stats: list[str]) -> dict:
+        res = {}
+        if "n" in stats: res["N"] = series.drop_nulls().len()
+        if "mean" in stats: res["Mean"] = float(series.mean()) if series.len() else float("nan")
+        if "sd" in stats: res["Std Dev"] = float(series.std()) if series.len() > 1 else float("nan")
+        if "min" in stats: res["Min"] = float(series.min()) if series.len() else float("nan")
+        if "max" in stats: res["Max"] = float(series.max()) if series.len() else float("nan")
+        if "median" in stats or "p50" in stats: res["Median"] = float(series.median()) if series.len() else float("nan")
+        if "sum" in stats: res["Sum"] = float(series.sum()) if series.len() else float("nan")
+        if "var" in stats: res["Variance"] = float(series.var()) if series.len() > 1 else float("nan")
+        return res
+
+    stat_labels = []
+    for s in stats_req:
+        lbl = {"n": "N", "mean": "Mean", "sd": "Std Dev", "min": "Min", "max": "Max",
+               "median": "Median", "p50": "Median", "sum": "Sum", "var": "Variance"}.get(s, s)
+        if lbl not in stat_labels:
+            stat_labels.append(lbl)
+
+    col_w = 12
+    lines = ["\ntabstat", "=" * (22 + col_w * len(stat_labels))]
+    header = f"{'Variable':<20}" + "".join(f"  {s:>{col_w}}" for s in stat_labels)
+    lines.append(header)
+    lines.append("-" * (22 + col_w * len(stat_labels)))
+
+    def _add_rows(data: pl.DataFrame, prefix: str = ""):
+        for col in cols:
+            try:
+                s = data[col].cast(pl.Float64)
+            except Exception:
+                continue
+            stat_vals = _compute_stats(s, stats_req)
+            row = f"{prefix + col:<20}"
+            for lbl in stat_labels:
+                val = stat_vals.get(lbl, float("nan"))
+                if isinstance(val, float) and val != val:
+                    row += f"  {'':>{col_w}}"
+                elif isinstance(val, int):
+                    row += f"  {val:>{col_w}}"
+                else:
+                    row += f"  {val:>{col_w}.4f}"
+            lines.append(row)
+
+    if by_var:
+        groups = df[by_var].unique().sort().to_list()
+        for g in groups:
+            lines.append(f"\n  {by_var} = {g}")
+            lines.append("-" * (22 + col_w * len(stat_labels)))
+            _add_rows(df.filter(pl.col(by_var) == g), "  ")
+    else:
+        _add_rows(df)
+
+    lines.append("=" * (22 + col_w * len(stat_labels)))
+    return "\n".join(lines)

openstat/commands/export_beamer_cmds.py

@@ -0,0 +1,142 @@
+"""Export results as LaTeX Beamer presentation."""
+
+from __future__ import annotations
+import os
+from datetime import date
+from pathlib import Path
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("export beamer", usage="export beamer [path] [--title=...] [--author=...] [--theme=Madrid]")
+def cmd_export_beamer(session: Session, args: str) -> str:
+    """Export analysis results as a LaTeX Beamer presentation (.tex).
+
+    Generates a slide deck with dataset summary, model results,
+    and references to saved plots.
+
+    Options:
+      --title=<txt>     presentation title (default: 'OpenStat Analysis')
+      --author=<txt>    author name
+      --theme=<t>       Beamer theme (default: Madrid)
+      --colortheme=<t>  Beamer colour theme (default: beaver)
+      --out=<path>      output .tex path
+
+    Examples:
+      export beamer
+      export beamer results/slides.tex --title="Income Analysis" --author="J. Smith"
+      export beamer --theme=Berlin --colortheme=whale
+    """
+    ca = CommandArgs(args)
+    out_path = (
+        ca.options.get("out")
+        or (ca.positional[0] if ca.positional else None)
+        or "outputs/presentation.tex"
+    )
+    title = ca.options.get("title", "OpenStat Analysis")
+    author = ca.options.get("author", "OpenStat")
+    theme = ca.options.get("theme", "Madrid")
+    color_theme = ca.options.get("colortheme", "beaver")
+
+    try:
+        lines = []
+
+        def L(s=""):
+            lines.append(s)
+
+        L(r"\documentclass{beamer}")
+        L(r"\usetheme{" + theme + "}")
+        L(r"\usecolortheme{" + color_theme + "}")
+        L(r"\usepackage{booktabs}")
+        L(r"\usepackage{graphicx}")
+        L(r"\usepackage{amsmath}")
+        L()
+        L(r"\title{" + title.replace("_", r"\_") + "}")
+        L(r"\author{" + author.replace("_", r"\_") + "}")
+        L(r"\date{" + date.today().isoformat() + "}")
+        L()
+        L(r"\begin{document}")
+        L()
+        L(r"\begin{frame}")
+        L(r"  \titlepage")
+        L(r"\end{frame}")
+        L()
+
+        # Dataset overview slide
+        ds_name = (session.dataset_name or "Unknown").replace("_", r"\_")
+        shape_str = session.shape_str
+        L(r"\begin{frame}{Dataset Overview}")
+        L(r"  \begin{itemize}")
+        L(r"    \item \textbf{Dataset:} " + ds_name)
+        L(r"    \item \textbf{Shape:} " + shape_str)
+        L(r"    \item \textbf{Date:} " + date.today().isoformat())
+        L(r"  \end{itemize}")
+        L(r"\end{frame}")
+        L()
+
+        # Model result slides
+        for mr in session.results:
+            model_title = f"{mr.name} — {mr.formula}"[:60].replace("_", r"\_")
+            L(r"\begin{frame}{" + model_title + "}")
+            L(r"  \scriptsize")
+            L(r"  \begin{verbatim}")
+            # Truncate table to fit slide
+            table_lines = mr.table.split("\n")[:25]
+            for tl in table_lines:
+                L("  " + tl[:80])
+            L(r"  \end{verbatim}")
+            # Model stats
+            d = mr.details
+            stats_parts = []
+            if d.get("n"):
+                stats_parts.append(f"N={d['n']}")
+            if d.get("r2") is not None:
+                stats_parts.append(f"R²={d['r2']:.3f}")
+            if d.get("aic") is not None:
+                stats_parts.append(f"AIC={d['aic']:.1f}")
+            if stats_parts:
+                L(r"  \medskip")
+                L(r"  \normalsize " + " \\quad ".join(stats_parts))
+            L(r"\end{frame}")
+            L()
+
+        # Plot slides
+        for plot_path in session.plot_paths:
+            if os.path.exists(plot_path):
+                safe_path = plot_path.replace("\\", "/").replace("_", r"\_")
+                base = os.path.basename(plot_path).replace("_", r"\_")
+                raw_path = plot_path.replace("\\", "/")
+                L(r"\begin{frame}{" + base + "}")
+                L(r"  \centering")
+                L(r"  \includegraphics[width=0.85\textwidth]{" + raw_path + "}")
+                L(r"\end{frame}")
+                L()
+
+        # Commands history slide
+        if session.history:
+            L(r"\begin{frame}[fragile]{Command History}")
+            L(r"  \scriptsize")
+            L(r"  \begin{verbatim}")
+            for h in session.history[-15:]:
+                L("  " + h[:80])
+            L(r"  \end{verbatim}")
+            L(r"\end{frame}")
+            L()
+
+        L(r"\end{document}")
+        L()
+
+        tex_content = "\n".join(lines)
+        Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+        Path(out_path).write_text(tex_content, encoding="utf-8")
+
+        abs_path = os.path.abspath(out_path)
+        n_slides = tex_content.count(r"\begin{frame}")
+        return (
+            f"LaTeX Beamer presentation saved: {abs_path}\n"
+            f"  Slides: {n_slides}  Theme: {theme}/{color_theme}\n"
+            f"  Compile: pdflatex {out_path}"
+        )
+    except Exception as e:
+        return friendly_error(e, "export beamer")