openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/posthoc_cmds.py

@@ -0,0 +1,153 @@
+"""Post-hoc comparison commands: posthoc (Tukey HSD, Bonferroni, Scheffé)."""
+
+from __future__ import annotations
+
+import re
+
+import numpy as np
+from scipy import stats
+from statsmodels.stats.multicomp import MultiComparison
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _fmt_table(title: str, headers: list[str], rows: list[tuple]) -> str:
+    all_rows = [tuple(str(v) for v in r) for r in rows]
+    widths = [
+        max(len(headers[i]), max((len(r[i]) for r in all_rows), default=0))
+        for i in range(len(headers))
+    ]
+    sep = "-" * (sum(widths) + 3 * len(widths) + 1)
+    header_line = " | ".join(f"{h:<{w}}" for h, w in zip(headers, widths))
+    lines = [f"\n{title}", "=" * len(sep), header_line, sep]
+    for row in all_rows:
+        lines.append(" | ".join(f"{v:<{w}}" for v, w in zip(row, widths)))
+    lines.append("=" * len(sep))
+    return "\n".join(lines)
+
+
+@command("posthoc", usage="posthoc <var> by(<group>) [--tukey|--bonferroni|--scheffe]")
+def cmd_posthoc(session: Session, args: str) -> str:
+    """Post-hoc pairwise comparisons after ANOVA (Tukey HSD, Bonferroni, Scheffé).
+
+    Examples:
+      posthoc score by(region)
+      posthoc income by(education) --bonferroni
+      posthoc age by(group) --scheffe
+    """
+    df = session.require_data()
+
+    m = re.search(r"by\((\w+)\)", args)
+    if not m:
+        return "Usage: posthoc <var> by(<group>) [--tukey|--bonferroni|--scheffe]"
+    group_col = m.group(1)
+
+    rest = re.sub(r"by\([^)]*\)", "", args)
+    tokens = [t for t in rest.split() if not t.startswith("--")]
+    if not tokens:
+        return "Usage: posthoc <var> by(<group>) [--tukey|--bonferroni|--scheffe]"
+    var = tokens[0]
+
+    if var not in df.columns:
+        return f"Column not found: {var}"
+    if group_col not in df.columns:
+        return f"Column not found: {group_col}"
+
+    method = "tukey"
+    if "--bonferroni" in args:
+        method = "bonferroni"
+    elif "--scheffe" in args:
+        method = "scheffe"
+
+    sub = df.select([var, group_col]).drop_nulls()
+    values = sub[var].to_numpy(allow_copy=True).astype(float)
+    groups = sub[group_col].to_list()
+
+    group_labels = sorted(set(str(g) for g in groups))
+    groups_str = [str(g) for g in groups]
+
+    if len(group_labels) < 2:
+        return "Need at least 2 groups for post-hoc comparison."
+
+    # Run overall ANOVA first
+    group_arrays = [values[np.array([g == lbl for g in groups_str])] for lbl in group_labels]
+    f_stat, p_overall = stats.f_oneway(*group_arrays)
+    anova_line = f"Overall ANOVA: F = {f_stat:.4f}, p = {p_overall:.4f}"
+
+    try:
+        if method == "tukey":
+            mc = MultiComparison(values, groups_str)
+            result = mc.tukeyhsd()
+            summary_data = result.summary().data
+            headers = ["Group1", "Group2", "MeanDiff", "Lower", "Upper", "p-adj", "Reject H0"]
+            rows = []
+            for row in summary_data[1:]:
+                g1, g2, meandiff, p_adj, lower, upper, reject = row
+                rows.append((
+                    str(g1), str(g2),
+                    f"{float(meandiff):.4f}",
+                    f"{float(lower):.4f}",
+                    f"{float(upper):.4f}",
+                    f"{float(p_adj):.4f}",
+                    "Yes" if reject else "No",
+                ))
+            return anova_line + _fmt_table("Tukey HSD Post-hoc Comparison", headers, rows)
+
+        elif method == "bonferroni":
+            n_pairs = len(group_labels) * (len(group_labels) - 1) // 2
+            alpha_adj = 0.05 / n_pairs
+            rows = []
+            for i in range(len(group_labels)):
+                for j in range(i + 1, len(group_labels)):
+                    a = group_arrays[i]
+                    b = group_arrays[j]
+                    t_stat, p_raw = stats.ttest_ind(a, b)
+                    p_adj = min(p_raw * n_pairs, 1.0)
+                    diff = np.mean(a) - np.mean(b)
+                    rows.append((
+                        group_labels[i], group_labels[j],
+                        f"{diff:.4f}",
+                        f"{t_stat:.4f}",
+                        f"{p_raw:.4f}",
+                        f"{p_adj:.4f}",
+                        "Yes" if p_adj < 0.05 else "No",
+                    ))
+            headers = ["Group1", "Group2", "MeanDiff", "t-stat", "p-raw", "p-adj(Bonf)", "Reject H0"]
+            note = f"\n  (Bonferroni correction: α_adj = 0.05/{n_pairs} = {alpha_adj:.5f})"
+            return anova_line + _fmt_table("Bonferroni Post-hoc Comparison", headers, rows) + note
+
+        elif method == "scheffe":
+            k = len(group_labels)
+            n_total = sum(len(d) for d in group_arrays)
+            n_per = [len(d) for d in group_arrays]
+            means = [np.mean(d) for d in group_arrays]
+
+            ss_within = sum(np.sum((d - np.mean(d)) ** 2) for d in group_arrays)
+            df_within = n_total - k
+            mse = ss_within / df_within
+            f_crit = stats.f.ppf(0.95, k - 1, df_within)
+            critical = (k - 1) * f_crit
+
+            rows = []
+            for i in range(k):
+                for j in range(i + 1, k):
+                    diff = means[i] - means[j]
+                    f_s = diff ** 2 / (mse * (1.0 / n_per[i] + 1.0 / n_per[j]))
+                    p_val = 1.0 - stats.f.cdf(f_s / (k - 1), k - 1, df_within)
+                    rows.append((
+                        group_labels[i], group_labels[j],
+                        f"{diff:.4f}",
+                        f"{f_s:.4f}",
+                        f"{critical:.4f}",
+                        f"{p_val:.4f}",
+                        "Yes" if f_s > critical else "No",
+                    ))
+            headers = ["Group1", "Group2", "MeanDiff", "F*", "F-critical", "p-value", "Reject H0"]
+            note = f"\n  (Scheffé critical value = (k-1)×F_crit = {k-1}×{f_crit:.4f} = {critical:.4f})"
+            return anova_line + _fmt_table("Scheffé Post-hoc Comparison", headers, rows) + note
+
+    except Exception as exc:
+        return f"posthoc error: {exc}"
+
+    return "Unknown method."

openstat/commands/power_cmds.py

@@ -0,0 +1,172 @@
+"""Power analysis commands: power, sampsi."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.commands.base import command
+from openstat.session import Session
+from openstat.stats.power import (
+    power_onemean,
+    power_twomeans,
+    power_oneproportion,
+    power_twoproportions,
+    power_ols,
+    sampsi as _sampsi,
+)
+
+
+# ── Stata-style argument parser ────────────────────────────────────────────
+
+def _stata_parse(raw: str) -> tuple[list[str], dict[str, str]]:
+    """Parse Stata-style args: positional tokens and key(value) options.
+
+    Handles:
+      - positional tokens (bare words, numbers)
+      - key(value) options  e.g. n(50), alpha(0.05)
+      - key=value options   e.g. n=50
+      - --flag / bare flag  e.g. --onesided, onesided
+      - commas are ignored (Stata separator)
+    """
+    opts: dict[str, str] = {}
+    positional: list[str] = []
+    flags: set[str] = set()
+
+    # key(value)
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+
+    # Remove key(value) tokens from raw for further parsing
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+
+    for tok in rest.split():
+        tok = tok.strip(',')
+        if not tok:
+            continue
+        if '=' in tok:
+            k, v = tok.split('=', 1)
+            opts[k.lower().lstrip('-')] = v
+        elif tok.startswith('--'):
+            flags.add(tok.lstrip('-').lower())
+        elif re.match(r'^-?(\d+\.?\d*|\.\d+)$', tok):
+            positional.append(tok)
+        elif re.match(r'^\w+$', tok):
+            # Could be a sub-command, flag, or positional
+            positional.append(tok)
+
+    return positional, opts, flags
+
+
+def _fmt_row(label: str, value) -> str:
+    return f"  {label:<30} {value}"
+
+
+def _power_table(result: dict) -> str:
+    lines = [f"\n{result['test']}", "-" * 50]
+    skip = {"test"}
+    for k, v in result.items():
+        if k in skip:
+            continue
+        if isinstance(v, float):
+            lines.append(_fmt_row(k, f"{v:.4f}"))
+        else:
+            lines.append(_fmt_row(k, v))
+    lines.append("-" * 50)
+    return "\n".join(lines)
+
+
+# ── Command ────────────────────────────────────────────────────────────────
+
+@command("power", usage="power onemean|twomeans|oneprop|twoprop|ols [options]")
+def cmd_power(session: Session, args: str) -> str:
+    """Power analysis for common statistical tests."""
+    positional, opts, flags = _stata_parse(args)
+
+    if not positional:
+        return (
+            "Usage: power <subcommand> [options]\n"
+            "Subcommands: onemean, twomeans, oneprop, twoprop, ols\n\n"
+            "Examples:\n"
+            "  power onemean, n(50) delta(0.5) sd(1)\n"
+            "  power twomeans, n(80) delta(0.5) sd(1)\n"
+            "  power oneprop, n(100) p0(0.5) pa(0.65)\n"
+            "  power twoprop, p1(0.3) p2(0.5) power(0.80)\n"
+            "  power ols, n(100) f2(0.15) k(3)"
+        )
+
+    sub = positional[0].lower()
+    alpha = float(opts.get("alpha", 0.05))
+    n = int(opts["n"]) if "n" in opts else None
+    pwr = float(opts["power"]) if "power" in opts else None
+    two_sided = "onesided" not in flags
+
+    try:
+        if sub in ("onemean", "one_mean"):
+            delta = float(opts.get("delta", 0.5))
+            sd = float(opts.get("sd", 1.0))
+            es = float(opts["es"]) if "es" in opts else None
+            result = power_onemean(
+                effect_size=es, alpha=alpha, n=n, power=pwr,
+                sd=sd, delta=delta, two_sided=two_sided,
+            )
+
+        elif sub in ("twomeans", "two_means"):
+            delta = float(opts.get("delta", 0.5))
+            sd = float(opts.get("sd", 1.0))
+            ratio = float(opts.get("ratio", 1.0))
+            n1 = int(opts["n1"]) if "n1" in opts else n
+            es = float(opts["es"]) if "es" in opts else None
+            result = power_twomeans(
+                effect_size=es, alpha=alpha, n=n1, power=pwr,
+                ratio=ratio, sd=sd, delta=delta, two_sided=two_sided,
+            )
+
+        elif sub in ("oneprop", "one_prop", "onepropo"):
+            p0 = float(opts.get("p0", 0.5))
+            pa = float(opts.get("pa", 0.6))
+            result = power_oneproportion(
+                p0=p0, pa=pa, alpha=alpha, n=n, power=pwr, two_sided=two_sided,
+            )
+
+        elif sub in ("twoprop", "two_prop", "twopropo"):
+            p1 = float(opts.get("p1", 0.3))
+            p2 = float(opts.get("p2", 0.5))
+            result = power_twoproportions(
+                p1=p1, p2=p2, alpha=alpha, n=n, power=pwr, two_sided=two_sided,
+            )
+
+        elif sub == "ols":
+            f2 = float(opts["f2"]) if "f2" in opts else None
+            k = int(opts.get("k", 1))
+            result = power_ols(f2=f2, alpha=alpha, n=n, power=pwr, k=k)
+
+        else:
+            return f"Unknown power subcommand: {sub}"
+
+    except (ValueError, TypeError) as exc:
+        return f"Power analysis error: {exc}"
+
+    return _power_table(result)
+
+
+@command("sampsi", usage="sampsi mu1 mu2 [, sd(1) alpha(0.05) power(0.80)]")
+def cmd_sampsi(session: Session, args: str) -> str:
+    """Compute required sample size (Stata-style sampsi)."""
+    positional, opts, flags = _stata_parse(args)
+
+    # Filter only numeric positionals
+    nums = [p for p in positional if re.match(r'^-?(\d+\.?\d*|\.\d+)$', p)]
+    if len(nums) < 2:
+        return "Usage: sampsi mu1 mu2 [, sd(1) alpha(0.05) power(0.80)]"
+
+    try:
+        mu1 = float(nums[0])
+        mu2 = float(nums[1])
+        sd = float(opts.get("sd", 1.0))
+        alpha = float(opts.get("alpha", 0.05))
+        pwr = float(opts.get("power", 0.80))
+        result = _sampsi(mu1=mu1, mu2=mu2, sd=sd, alpha=alpha, power=pwr)
+    except (ValueError, TypeError) as exc:
+        return f"sampsi error: {exc}"
+
+    return _power_table(result)

openstat/commands/profile_cmds.py

@@ -0,0 +1,246 @@
+"""Data profile and data dictionary commands."""
+
+from __future__ import annotations
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("profile", usage="profile [col1 col2 ...] [--out=report.html]")
+def cmd_profile(session: Session, args: str) -> str:
+    """Generate a comprehensive data profile report.
+
+    Shows for each column: type, missing count/%, unique values,
+    min/max/mean/std/median/mode, top values, distribution shape.
+
+    Options:
+      --out=<path>    save as HTML report (default: outputs/profile.html)
+      --cols=<list>   comma-separated column subset
+
+    Examples:
+      profile
+      profile income age education
+      profile --out=data_profile.html
+    """
+    import polars as pl
+
+    ca = CommandArgs(args)
+    try:
+        df = session.require_data()
+    except RuntimeError as e:
+        return str(e)
+
+    # Column subset
+    cols_opt = ca.options.get("cols")
+    if cols_opt:
+        cols = [c.strip() for c in cols_opt.split(",")]
+    elif ca.positional:
+        cols = ca.positional
+    else:
+        cols = df.columns
+
+    missing_cols = [c for c in cols if c not in df.columns]
+    if missing_cols:
+        return f"Columns not found: {', '.join(missing_cols)}"
+
+    NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+               pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+
+    lines = [
+        f"Data Profile: {session.dataset_name or 'dataset'}",
+        f"Shape: {df.height:,} rows × {df.width} columns  |  Showing {len(cols)} columns",
+        "=" * 72,
+    ]
+
+    for col in cols:
+        series = df[col]
+        n_miss = series.null_count()
+        miss_pct = 100 * n_miss / df.height if df.height else 0
+        n_uniq = series.drop_nulls().n_unique()
+        dtype = str(series.dtype)
+
+        lines.append(f"\n  {col}  [{dtype}]")
+        lines.append(f"    Missing:  {n_miss:,} ({miss_pct:.1f}%)")
+        lines.append(f"    Unique:   {n_uniq:,}")
+
+        if series.dtype in NUMERIC:
+            s = series.drop_nulls()
+            if s.len() > 0:
+                lines.append(f"    Mean:     {s.mean():.4f}")
+                lines.append(f"    Std:      {s.std():.4f}" if s.len() > 1 else "    Std:      —")
+                lines.append(f"    Min:      {s.min():.4f}")
+                lines.append(f"    Median:   {s.median():.4f}")
+                lines.append(f"    Max:      {s.max():.4f}")
+                # Skewness / kurtosis
+                try:
+                    import numpy as np
+                    arr = s.to_numpy()
+                    from scipy.stats import skew, kurtosis
+                    lines.append(f"    Skewness: {skew(arr):.3f}")
+                    lines.append(f"    Kurtosis: {kurtosis(arr):.3f}")
+                except Exception:
+                    pass
+                # Zeros / negatives
+                n_zero = int((s == 0).sum())
+                n_neg = int((s < 0).sum())
+                if n_zero or n_neg:
+                    lines.append(f"    Zeros:    {n_zero:,}   Negative: {n_neg:,}")
+        else:
+            # Categorical / string
+            s = series.drop_nulls().cast(pl.Utf8)
+            top = s.value_counts().sort("count", descending=True).head(5)
+            if top.height > 0:
+                top_vals = ", ".join(
+                    f"{row[0]}({row[1]})" for row in top.iter_rows()
+                )
+                lines.append(f"    Top 5:    {top_vals}")
+
+    lines.append("\n" + "=" * 72)
+
+    # HTML output
+    out_path = ca.options.get("out")
+    if out_path:
+        try:
+            _save_profile_html(lines, out_path, session)
+            lines.append(f"\nHTML report saved: {out_path}")
+        except Exception as exc:
+            lines.append(f"\nHTML save failed: {exc}")
+
+    return "\n".join(lines)
+
+
+def _save_profile_html(lines: list[str], path: str, session: Session) -> None:
+    """Save a simple HTML version of the profile."""
+    import polars as pl
+    from pathlib import Path
+
+    df = session.df
+    NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+               pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+
+    rows_html = ""
+    if df is not None:
+        for col in df.columns:
+            series = df[col]
+            n_miss = series.null_count()
+            miss_pct = f"{100*n_miss/df.height:.1f}%" if df.height else "—"
+            n_uniq = series.drop_nulls().n_unique()
+            dtype = str(series.dtype)
+            if series.dtype in NUMERIC:
+                s = series.drop_nulls()
+                stats = f"mean={s.mean():.3f}, std={s.std():.3f}" if s.len() > 0 else "—"
+            else:
+                stats = f"{n_uniq} unique values"
+            rows_html += (
+                f"<tr><td>{col}</td><td>{dtype}</td>"
+                f"<td>{n_miss} ({miss_pct})</td>"
+                f"<td>{n_uniq}</td><td>{stats}</td></tr>\n"
+            )
+
+    html = f"""<!DOCTYPE html>
+<html><head><meta charset="utf-8">
+<title>OpenStat Data Profile</title>
+<style>
+body {{font-family: sans-serif; margin: 2em; background: #f9f9f9;}}
+h1 {{color: #333;}} table {{border-collapse: collapse; width: 100%;}}
+th {{background: #4C72B0; color: white; padding: 8px;}}
+td {{border: 1px solid #ddd; padding: 6px;}}
+tr:nth-child(even) {{background: #f0f4ff;}}
+</style></head><body>
+<h1>Data Profile: {session.dataset_name or "dataset"}</h1>
+<p>Shape: {session.shape_str}</p>
+<table>
+<tr><th>Column</th><th>Type</th><th>Missing</th><th>Unique</th><th>Stats</th></tr>
+{rows_html}
+</table>
+<pre>{"chr(10)".join(lines)}</pre>
+</body></html>"""
+
+    Path(path).parent.mkdir(parents=True, exist_ok=True)
+    Path(path).write_text(html, encoding="utf-8")
+
+
+@command("datadict", usage="datadict [--out=dict.xlsx|dict.md]")
+def cmd_datadict(session: Session, args: str) -> str:
+    """Generate a data dictionary for the current dataset.
+
+    Creates a table with: variable name, type, missing%, unique count,
+    min/max/mean for numeric, top values for categorical.
+
+    Options:
+      --out=<path>   save to Excel (.xlsx) or Markdown (.md)
+                     Default: outputs/data_dictionary.md
+
+    Examples:
+      datadict
+      datadict --out=dictionary.xlsx
+      datadict --out=docs/variables.md
+    """
+    import polars as pl
+    from pathlib import Path
+
+    ca = CommandArgs(args)
+    out_path = ca.options.get("out", "outputs/data_dictionary.md")
+
+    try:
+        df = session.require_data()
+    except RuntimeError as e:
+        return str(e)
+
+    NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+               pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+
+    records = []
+    for col in df.columns:
+        series = df[col]
+        n_miss = series.null_count()
+        miss_pct = f"{100*n_miss/df.height:.1f}%"
+        n_uniq = series.drop_nulls().n_unique()
+        dtype = str(series.dtype)
+
+        if series.dtype in NUMERIC:
+            s = series.drop_nulls()
+            if s.len() > 0:
+                extra = f"mean={s.mean():.3f}; range=[{s.min():.3f},{s.max():.3f}]"
+            else:
+                extra = "all missing"
+        else:
+            top = series.drop_nulls().cast(pl.Utf8).value_counts().sort("count", descending=True).head(3)
+            top_vals = "; ".join(str(r[0]) for r in top.iter_rows())
+            extra = f"top: {top_vals}"
+
+        records.append({
+            "Variable": col,
+            "Type": dtype,
+            "Missing": f"{n_miss} ({miss_pct})",
+            "Unique": str(n_uniq),
+            "Notes": extra,
+            "Description": "",  # user fills in
+        })
+
+    Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+
+    if out_path.endswith(".xlsx"):
+        try:
+            dict_df = pl.DataFrame(records)
+            dict_df.write_excel(out_path)
+            return f"Data dictionary saved: {out_path} ({len(records)} variables)"
+        except ImportError:
+            return "xlsxwriter required for Excel output. Try --out=dict.md"
+
+    else:  # Markdown
+        lines = [
+            f"# Data Dictionary: {session.dataset_name or 'dataset'}",
+            f"",
+            f"Shape: {df.height:,} rows × {df.width} columns",
+            f"",
+            "| Variable | Type | Missing | Unique | Notes | Description |",
+            "|---|---|---|---|---|---|",
+        ]
+        for r in records:
+            lines.append(
+                f"| {r['Variable']} | {r['Type']} | {r['Missing']} | "
+                f"{r['Unique']} | {r['Notes']} | {r['Description']} |"
+            )
+        Path(out_path).write_text("\n".join(lines), encoding="utf-8")
+        return f"Data dictionary saved: {out_path} ({len(records)} variables)"

openstat/commands/rbridge_cmds.py

@@ -0,0 +1,81 @@
+"""R bridge command: run R code from OpenStat (requires rpy2)."""
+
+from __future__ import annotations
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("r", usage='r "<R code>"')
+def cmd_r(session: Session, args: str) -> str:
+    """Execute R code in the current session (requires rpy2).
+
+    The current dataset is available in R as 'data'.
+    Results printed in R are captured and returned.
+    Modified 'data' is pulled back into the OpenStat session.
+
+    Examples:
+      r "summary(data)"
+      r "cor(data[, sapply(data, is.numeric)])"
+      r "data$log_income <- log(data$income + 1)"
+      r "lm_result <- lm(y ~ x1 + x2, data=data); summary(lm_result)"
+    """
+    try:
+        import rpy2.robjects as ro
+        from rpy2.robjects import pandas2ri
+        from rpy2.robjects.conversion import localconverter
+        import rpy2.rinterface_lib.callbacks as rcb
+    except ImportError:
+        return (
+            "rpy2 is required for the R bridge.\n"
+            "Install: pip install rpy2\n"
+            "Also requires a working R installation."
+        )
+
+    code = args.strip().strip('"\'')
+    if not code:
+        return 'Usage: r "<R code>"'
+
+    import io as _io
+    output_lines: list[str] = []
+
+    # Capture R output
+    def _capture(x):
+        output_lines.append(x)
+
+    old_write = rcb.consolewrite_print
+    rcb.consolewrite_print = _capture
+
+    try:
+        with localconverter(ro.default_converter + pandas2ri.converter):
+            # Push current dataframe into R as 'data'
+            if session.df is not None:
+                try:
+                    r_df = ro.conversion.py2rpy(session.df.to_pandas())
+                    ro.globalenv["data"] = r_df
+                except Exception:
+                    pass  # non-critical
+
+            # Execute R code
+            ro.r(code)
+
+            # Pull 'data' back if it was modified
+            try:
+                r_data = ro.globalenv.get("data")
+                if r_data is not None:
+                    import polars as pl
+                    pd_df = ro.conversion.rpy2py(r_data)
+                    new_df = pl.from_pandas(pd_df)
+                    if session.df is None or not new_df.equals(session.df):
+                        session.snapshot()
+                        session.df = new_df
+            except Exception:
+                pass
+
+    except Exception as e:
+        return friendly_error(e, "R bridge")
+    finally:
+        rcb.consolewrite_print = old_write
+
+    result = "".join(output_lines).strip()
+    return result or "[R code executed — no output]"