openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/pipeline_cmds.py

@@ -0,0 +1,319 @@
+"""Pipeline, batch processing, git integration, progress bars, config profiles."""
+
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+# ── Pipeline ─────────────────────────────────────────────────────────────────
+
+@command("pipeline", usage="pipeline define|run|list|show|rm <name> [commands...]")
+def cmd_pipeline(session: Session, args: str) -> str:
+    """Define and run named command pipelines.
+
+    A pipeline is a named sequence of commands that can be run in one go.
+    Pipelines are stored in the session and can be saved via 'session save'.
+
+    Sub-commands:
+      pipeline define <name> <cmd1> | <cmd2> | ...  — define a pipeline
+      pipeline run <name>                            — run a defined pipeline
+      pipeline list                                  — list all pipelines
+      pipeline show <name>                           — show pipeline steps
+      pipeline rm <name>                             — remove a pipeline
+
+    Examples:
+      pipeline define clean "drop id" | "rename old_name new_name" | "generate x2 = x*x"
+      pipeline run clean
+      pipeline define model_run "ols y x1 x2" | "plot coef" | "export pdf"
+      pipeline run model_run
+    """
+    _PIPELINES: dict = getattr(session, "_pipelines", {})
+    if not hasattr(session, "_pipelines"):
+        session._pipelines = _PIPELINES  # type: ignore[attr-defined]
+
+    tokens = args.strip().split(None, 2)
+    if not tokens:
+        return "Usage: pipeline define|run|list|show|rm <name> [steps]"
+    subcmd = tokens[0].lower()
+
+    if subcmd == "list":
+        if not _PIPELINES:
+            return "No pipelines defined. Use: pipeline define <name> <cmd> | <cmd>"
+        lines = ["Defined pipelines:"]
+        for name, steps in _PIPELINES.items():
+            lines.append(f"  {name} ({len(steps)} steps)")
+        return "\n".join(lines)
+
+    if subcmd == "rm":
+        name = tokens[1] if len(tokens) > 1 else ""
+        if not name:
+            return "Usage: pipeline rm <name>"
+        if name in _PIPELINES:
+            del _PIPELINES[name]
+            return f"Pipeline '{name}' removed."
+        return f"Pipeline '{name}' not found."
+
+    if subcmd == "show":
+        name = tokens[1] if len(tokens) > 1 else ""
+        if name not in _PIPELINES:
+            return f"Pipeline '{name}' not found."
+        steps = _PIPELINES[name]
+        lines = [f"Pipeline '{name}' ({len(steps)} steps):"]
+        for i, step in enumerate(steps, 1):
+            lines.append(f"  {i}. {step}")
+        return "\n".join(lines)
+
+    if subcmd == "define":
+        if len(tokens) < 3:
+            return "Usage: pipeline define <name> <cmd1> | <cmd2> | ..."
+        name = tokens[1]
+        rest = tokens[2]
+        steps = [s.strip().strip('"\'') for s in rest.split("|")]
+        steps = [s for s in steps if s]
+        _PIPELINES[name] = steps
+        return f"Pipeline '{name}' defined with {len(steps)} steps."
+
+    if subcmd == "run":
+        name = tokens[1] if len(tokens) > 1 else ""
+        if not name:
+            return "Usage: pipeline run <name>"
+        if name not in _PIPELINES:
+            return f"Pipeline '{name}' not found. Use 'pipeline list' to see available."
+        steps = _PIPELINES[name]
+        from openstat.commands.base import run_command
+        results = [f"Running pipeline '{name}' ({len(steps)} steps):", ""]
+        for i, step in enumerate(steps, 1):
+            results.append(f"[{i}/{len(steps)}] {step}")
+            try:
+                out = run_command(session, step)
+                if out:
+                    results.append(f"  → {out[:200]}")
+            except Exception as exc:
+                results.append(f"  → ERROR: {exc}")
+                results.append(f"Pipeline stopped at step {i}.")
+                break
+        results.append("")
+        results.append("Pipeline complete.")
+        return "\n".join(results)
+
+    return f"Unknown pipeline sub-command: {subcmd}"
+
+
+# ── Batch ────────────────────────────────────────────────────────────────────
+
+@command("batch", usage="batch <script1.ost> [script2.ost ...] [--stop-on-error]")
+def cmd_batch(session: Session, args: str) -> str:
+    """Run multiple script files in sequence.
+
+    Options:
+      --stop-on-error   halt if any script fails (default: continue)
+      --fresh           start each script with a fresh session
+
+    Examples:
+      batch clean.ost model.ost report.ost
+      batch *.ost --stop-on-error
+    """
+    import glob as _glob
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: batch <script1.ost> [script2.ost ...] [--stop-on-error]"
+
+    stop_on_error = "--stop-on-error" in args
+    fresh = "--fresh" in args
+
+    # Expand glob patterns
+    files = []
+    for pat in ca.positional:
+        matched = sorted(_glob.glob(pat))
+        if matched:
+            files.extend(matched)
+        else:
+            files.append(pat)
+
+    if not files:
+        return "No script files found."
+
+    from openstat.script_runner import run_script_advanced
+    results = [f"Batch: {len(files)} scripts", ""]
+    errors = 0
+
+    for i, fpath in enumerate(files, 1):
+        if not Path(fpath).exists():
+            msg = f"[{i}/{len(files)}] SKIP {fpath} — file not found"
+            results.append(msg)
+            errors += 1
+            if stop_on_error:
+                break
+            continue
+
+        results.append(f"[{i}/{len(files)}] Running: {fpath}")
+        try:
+            run_sess = Session() if fresh else session
+            run_script_advanced(fpath, run_sess)
+            results.append(f"  → OK")
+        except Exception as exc:
+            results.append(f"  → ERROR: {exc}")
+            errors += 1
+            if stop_on_error:
+                results.append("Stopped due to error (--stop-on-error).")
+                break
+
+    results += ["", f"Batch complete. {len(files) - errors}/{len(files)} scripts succeeded."]
+    return "\n".join(results)
+
+
+# ── Git integration ──────────────────────────────────────────────────────────
+
+@command("git", usage="git init|status|add|commit|log|diff [args]")
+def cmd_git(session: Session, args: str) -> str:
+    """Git version control for scripts and outputs (requires git).
+
+    Runs git commands in the current working directory.
+    Useful for versioning analysis scripts.
+
+    Sub-commands:
+      git init                    — initialize a git repository
+      git status                  — show working tree status
+      git add <file> [file2 ...]  — stage files
+      git commit "<message>"      — commit staged changes
+      git log [--n=10]            — show recent commits
+      git diff [<file>]           — show unstaged changes
+      git tag <name>              — create a tag for this analysis version
+
+    Examples:
+      git init
+      git add analysis.ost outputs/results.pdf
+      git commit "Add OLS regression results"
+      git log --n=5
+    """
+    tokens = args.strip().split(None, 1)
+    if not tokens:
+        return "Usage: git init|status|add|commit|log|diff [args]"
+
+    subcmd = tokens[0].lower()
+    rest = tokens[1].strip() if len(tokens) > 1 else ""
+
+    try:
+        import subprocess
+
+        def _run(cmd_parts):
+            result = subprocess.run(
+                cmd_parts, capture_output=True, text=True, cwd=os.getcwd()
+            )
+            out = (result.stdout + result.stderr).strip()
+            return out or "(no output)"
+
+        if subcmd == "init":
+            return _run(["git", "init"])
+        elif subcmd == "status":
+            return _run(["git", "status", "--short"])
+        elif subcmd == "add":
+            files = rest.split() if rest else ["."]
+            return _run(["git", "add"] + files)
+        elif subcmd == "commit":
+            msg = rest.strip().strip('"\'') or "OpenStat analysis update"
+            return _run(["git", "commit", "-m", msg])
+        elif subcmd == "log":
+            n = 10
+            if "--n=" in rest:
+                try:
+                    n = int(rest.split("--n=")[1].split()[0])
+                except Exception:
+                    pass
+            return _run(["git", "log", f"--oneline", f"-{n}"])
+        elif subcmd == "diff":
+            file_arg = [rest] if rest else []
+            return _run(["git", "diff"] + file_arg)
+        elif subcmd == "tag":
+            tag = rest.strip().strip('"\'')
+            if not tag:
+                return "Usage: git tag <name>"
+            return _run(["git", "tag", tag])
+        else:
+            # Pass through to git directly
+            return _run(["git", subcmd] + (rest.split() if rest else []))
+    except FileNotFoundError:
+        return "git not found. Install git: https://git-scm.com/"
+    except Exception as e:
+        return friendly_error(e, "git")
+
+
+# ── Config profiles ───────────────────────────────────────────────────────────
+
+@command("profile config", usage="profile config save|load|list|rm <name>")
+def cmd_config_profile(session: Session, args: str) -> str:
+    """Save and load configuration profiles.
+
+    A profile saves the current config (output dir, plot size, etc.)
+    with a name so you can switch between setups.
+
+    Examples:
+      profile config save presentation
+      profile config save publication
+      profile config load presentation
+      profile config list
+      profile config rm presentation
+    """
+    import json
+    from openstat.config import get_config
+
+    PROFILE_DIR = Path.home() / ".openstat" / "profiles"
+    PROFILE_DIR.mkdir(parents=True, exist_ok=True)
+
+    tokens = args.strip().split()
+    if not tokens:
+        return "Usage: profile config save|load|list|rm <name>"
+
+    subcmd = tokens[0].lower()
+    name = tokens[1] if len(tokens) > 1 else ""
+
+    if subcmd == "list":
+        profiles = list(PROFILE_DIR.glob("*.json"))
+        if not profiles:
+            return "No saved profiles. Use: profile config save <name>"
+        lines = ["Saved config profiles:"]
+        for p in profiles:
+            lines.append(f"  {p.stem}")
+        return "\n".join(lines)
+
+    if not name:
+        return f"Usage: profile config {subcmd} <name>"
+
+    profile_path = PROFILE_DIR / f"{name}.json"
+
+    if subcmd == "save":
+        cfg = get_config()
+        data = {
+            "output_dir": str(cfg.output_dir),
+            "plot_figsize_w": cfg.plot_figsize_w,
+            "plot_figsize_h": cfg.plot_figsize_h,
+            "plot_dpi": cfg.plot_dpi,
+            "csv_separator": cfg.csv_separator,
+            "max_undo_stack": cfg.max_undo_stack,
+        }
+        profile_path.write_text(json.dumps(data, indent=2), encoding="utf-8")
+        return f"Profile '{name}' saved to {profile_path}"
+
+    elif subcmd == "load":
+        if not profile_path.exists():
+            return f"Profile '{name}' not found. Use 'profile config list' to see available."
+        data = json.loads(profile_path.read_text(encoding="utf-8"))
+        cfg = get_config()
+        for k, v in data.items():
+            if hasattr(cfg, k):
+                setattr(cfg, k, v)
+        return f"Profile '{name}' loaded: {data}"
+
+    elif subcmd == "rm":
+        if not profile_path.exists():
+            return f"Profile '{name}' not found."
+        profile_path.unlink()
+        return f"Profile '{name}' removed."
+
+    else:
+        return f"Unknown sub-command: {subcmd}. Use save, load, list, or rm."

openstat/commands/plot_cmds.py

@@ -0,0 +1,189 @@
+"""Plot commands: hist, scatter, line, box, bar, heatmap."""
+
+from __future__ import annotations
+
+from openstat.session import Session
+from openstat.plots.plotter import (
+    plot_histogram, plot_scatter, plot_line, plot_box, plot_bar, plot_heatmap,
+    plot_residuals_vs_fitted, plot_qq, plot_scale_location, plot_coef,
+    plot_interaction,
+)
+from openstat.commands.base import command, CommandArgs, friendly_error
+
+
+@command("plot", usage="plot hist|scatter|line|box|bar|heatmap|coef|interaction ...")
+def cmd_plot(session: Session, args: str) -> str:
+    """Create plots: hist, scatter, line, box, bar, heatmap, coef, interaction."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return (
+            "Usage:\n"
+            "  plot hist <col>\n"
+            "  plot scatter <y> <x>\n"
+            "  plot line <y> <x>\n"
+            "  plot box <col> [by <group_col>]\n"
+            "  plot bar <col> [by <group_col>]\n"
+            "  plot heatmap [col1 col2 ...]\n"
+            "  plot coef                      (coefficient plot after model)\n"
+            "  plot margins                   (marginal effects plot after margins)\n"
+            "  plot interaction <y> <x> <mod> (interaction plot, ±1SD split)\n"
+            "  plot diagnostics               (diagnostic plots after model)"
+        )
+
+    subcmd = ca.positional[0]
+    try:
+        if subcmd == "hist":
+            if len(ca.positional) < 2:
+                return "Usage: plot hist <col>"
+            col = ca.positional[1]
+            path = plot_histogram(df, col, session.output_dir)
+            session.plot_paths.append(str(path))
+            return f"Histogram saved: {path}"
+
+        elif subcmd == "scatter":
+            if len(ca.positional) < 3:
+                return "Usage: plot scatter <y_col> <x_col>"
+            y_col, x_col = ca.positional[1], ca.positional[2]
+            path = plot_scatter(df, y_col, x_col, session.output_dir)
+            session.plot_paths.append(str(path))
+            return f"Scatter plot saved: {path}"
+
+        elif subcmd == "line":
+            if len(ca.positional) < 3:
+                return "Usage: plot line <y_col> <x_col>"
+            y_col, x_col = ca.positional[1], ca.positional[2]
+            path = plot_line(df, y_col, x_col, session.output_dir)
+            session.plot_paths.append(str(path))
+            return f"Line plot saved: {path}"
+
+        elif subcmd == "box":
+            if len(ca.positional) < 2:
+                return "Usage: plot box <col> [by <group_col>]"
+            col = ca.positional[1]
+            by_rest = ca.rest_after("by")
+            group_col = by_rest.split()[0] if by_rest else None
+            path = plot_box(df, col, session.output_dir, group_col=group_col)
+            session.plot_paths.append(str(path))
+            return f"Box plot saved: {path}"
+
+        elif subcmd == "bar":
+            if len(ca.positional) < 2:
+                return "Usage: plot bar <col> [by <group_col>]"
+            col = ca.positional[1]
+            by_rest = ca.rest_after("by")
+            group_col = by_rest.split()[0] if by_rest else None
+            path = plot_bar(df, col, session.output_dir, group_col=group_col)
+            session.plot_paths.append(str(path))
+            return f"Bar chart saved: {path}"
+
+        elif subcmd == "heatmap":
+            cols = ca.positional[1:] if len(ca.positional) > 1 else None
+            path = plot_heatmap(df, cols, session.output_dir)
+            session.plot_paths.append(str(path))
+            return f"Heatmap saved: {path}"
+
+        elif subcmd == "acf":
+            if len(ca.positional) < 2:
+                return "Usage: plot acf <col>"
+            col = ca.positional[1]
+            from openstat.plots.ts_plots import plot_acf
+            series = df[col].drop_nulls().to_numpy()
+            path = plot_acf(series, col, session.output_dir)
+            session.plot_paths.append(str(path))
+            return f"ACF plot saved: {path}"
+
+        elif subcmd == "pacf":
+            if len(ca.positional) < 2:
+                return "Usage: plot pacf <col>"
+            col = ca.positional[1]
+            from openstat.plots.ts_plots import plot_pacf
+            series = df[col].drop_nulls().to_numpy()
+            path = plot_pacf(series, col, session.output_dir)
+            session.plot_paths.append(str(path))
+            return f"PACF plot saved: {path}"
+
+        elif subcmd == "coef":
+            # session._last_model is the raw statsmodels result object
+            raw = session._last_model
+            if raw is None:
+                return "No model fitted yet. Run ols/logit/etc. first, then plot coef."
+            if not hasattr(raw, "params"):
+                return "Current model does not support coefficient plots."
+            import numpy as np
+            # Get parameter names from model or FitResult
+            fit_result = session._last_fit_result
+            if fit_result is not None and hasattr(fit_result, "params") and isinstance(fit_result.params, dict):
+                names = list(fit_result.params.keys())
+                coef_vals = [fit_result.params[n] for n in names]
+                se_vals = [fit_result.std_errors.get(n, 0.0) for n in names]
+                params = dict(zip(names, coef_vals))
+                ci_lower = {n: v - 1.96 * se for n, v, se in zip(names, coef_vals, se_vals)}
+                ci_upper = {n: v + 1.96 * se for n, v, se in zip(names, coef_vals, se_vals)}
+            else:
+                # Fallback: use exog_names from the statsmodels model
+                names = list(getattr(getattr(raw, "model", None), "exog_names", None) or [])
+                coef_arr = np.atleast_1d(raw.params)
+                if not names:
+                    names = [f"x{i}" for i in range(len(coef_arr))]
+                params = dict(zip(names, coef_arr.tolist()))
+                try:
+                    ci_arr = np.atleast_2d(raw.conf_int())
+                    ci_lower = dict(zip(names, ci_arr[:, 0].tolist()))
+                    ci_upper = dict(zip(names, ci_arr[:, 1].tolist()))
+                except Exception:
+                    se_arr = np.atleast_1d(raw.bse)
+                    ci_lower = {n: v - 1.96 * se for n, v, se in zip(names, coef_arr, se_arr)}
+                    ci_upper = {n: v + 1.96 * se for n, v, se in zip(names, coef_arr, se_arr)}
+            model_cls = type(getattr(raw, "model", raw)).__name__
+            title = f"Coefficient Plot ({model_cls})"
+            path = plot_coef(params, ci_lower, ci_upper, session.output_dir, title=title)
+            session.plot_paths.append(str(path))
+            return f"Coefficient plot saved: {path}"
+
+        elif subcmd == "margins":
+            mg = session._last_margins
+            if mg is None:
+                return "No margins result. Run 'margins' after logit/probit first."
+            if not hasattr(mg, "effects"):
+                return "Stored margins result has no 'effects' attribute."
+            params = dict(mg.effects)
+            ci_lower = dict(mg.conf_int_low)
+            ci_upper = dict(mg.conf_int_high)
+            path = plot_coef(
+                params, ci_lower, ci_upper, session.output_dir,
+                title=f"Marginal Effects ({mg.method})",
+                drop_const=False,
+            )
+            session.plot_paths.append(str(path))
+            return f"Marginal effects plot saved: {path}"
+
+        elif subcmd == "interaction":
+            # plot interaction <y> <x> <moderator> [--levels=N]
+            if len(ca.positional) < 4:
+                return "Usage: plot interaction <y> <x> <moderator> [--levels=3]"
+            y_col = ca.positional[1]
+            x_col = ca.positional[2]
+            mod_col = ca.positional[3]
+            n_levels = int(ca.options.get("levels", 3))
+            path = plot_interaction(df, y_col, x_col, mod_col, session.output_dir, n_levels=n_levels)
+            session.plot_paths.append(str(path))
+            return f"Interaction plot saved: {path}"
+
+        elif subcmd == "diagnostics":
+            if session._last_model is None or session._last_model_vars is None:
+                return "No model fitted yet. Run ols first, then plot diagnostics."
+            from openstat.stats.models import compute_residuals
+            dep, indeps = session._last_model_vars
+            diag = compute_residuals(session._last_model, df, dep, indeps)
+            paths = []
+            paths.append(plot_residuals_vs_fitted(diag["fitted"], diag["residuals"], session.output_dir))
+            paths.append(plot_qq(diag["std_residuals"], session.output_dir))
+            paths.append(plot_scale_location(diag["fitted"], diag["std_residuals"], session.output_dir))
+            session.plot_paths.extend(str(p) for p in paths)
+            return "Diagnostic plots saved:\n" + "\n".join(f"  {p}" for p in paths)
+
+        else:
+            return f"Unknown plot type: {subcmd}. Available: hist, scatter, line, box, bar, heatmap, coef, margins, interaction, diagnostics"
+    except Exception as e:
+        return friendly_error(e, "Plot error")

openstat/commands/plugin_cmds.py

@@ -0,0 +1,79 @@
+"""Plugin management commands: plugin list, plugin info."""
+
+from __future__ import annotations
+
+from rich.console import Console
+from rich.table import Table
+
+from openstat.session import Session
+from openstat.commands.base import command, rich_to_str
+
+
+# Global plugin manager — initialized at REPL startup
+_manager = None
+
+
+def get_plugin_manager():
+    global _manager
+    if _manager is None:
+        from openstat.plugins.manager import PluginManager
+        _manager = PluginManager()
+    return _manager
+
+
+def init_plugins() -> list[str]:
+    """Discover and load all plugins. Called at REPL startup."""
+    mgr = get_plugin_manager()
+    return mgr.discover()
+
+
+@command("plugin", usage="plugin list | plugin info <name>")
+def cmd_plugin(session: Session, args: str) -> str:
+    """Manage plugins: list installed plugins or show plugin details."""
+    mgr = get_plugin_manager()
+    parts = args.strip().split(None, 1)
+    subcmd = parts[0].lower() if parts else ""
+
+    if subcmd == "list":
+        plugins = mgr.list_plugins()
+        if not plugins:
+            return "No plugins installed. Install plugins with: pip install <plugin-package>"
+
+        def render(console: Console) -> None:
+            table = Table(title="Installed Plugins")
+            table.add_column("Name", style="cyan")
+            table.add_column("Version", justify="right")
+            table.add_column("Description")
+            table.add_column("Commands", style="green")
+            for p in plugins:
+                table.add_row(
+                    p.name, p.version, p.description,
+                    ", ".join(p.commands) if p.commands else "—",
+                )
+            console.print(table)
+
+        errors = mgr.errors
+        result = rich_to_str(render)
+        if errors:
+            result += "\n\nFailed to load:"
+            for name, err in errors.items():
+                result += f"\n  {name}: {err}"
+        return result
+
+    elif subcmd == "info":
+        name = parts[1].strip() if len(parts) > 1 else ""
+        if not name:
+            return "Usage: plugin info <name>"
+        info = mgr.get_info(name)
+        if info is None:
+            return f"Plugin '{name}' not found. Use 'plugin list' to see installed plugins."
+        lines = [
+            f"Plugin: {info.name}",
+            f"Version: {info.version}",
+            f"Description: {info.description or '(none)'}",
+            f"Commands: {', '.join(info.commands) if info.commands else '(none)'}",
+        ]
+        return "\n".join(lines)
+
+    else:
+        return "Usage: plugin list | plugin info <name>"