openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/textanalysis_cmds.py

@@ -0,0 +1,192 @@
+"""Text analysis: TF-IDF, word frequency, topic modeling (LDA)."""
+
+from __future__ import annotations
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("textfreq", usage="textfreq <col> [--top=20] [--stopwords]")
+def cmd_textfreq(session: Session, args: str) -> str:
+    """Word frequency analysis for a text column.
+
+    Options:
+      --top=<n>       show top N words (default: 20)
+      --stopwords     remove common English stopwords
+      --min=<n>       minimum word length (default: 2)
+
+    Examples:
+      textfreq review_text --top=30 --stopwords
+      textfreq title --min=4
+    """
+    import re
+    from collections import Counter
+    import polars as pl
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: textfreq <col> [--top=20]"
+
+    col = ca.positional[0]
+    top_n = int(ca.options.get("top", 20))
+    use_stopwords = "stopwords" in ca.flags
+    min_len = int(ca.options.get("min", 2))
+
+    STOPWORDS = {
+        "the", "a", "an", "and", "or", "but", "in", "on", "at", "to", "for",
+        "of", "with", "by", "from", "is", "was", "are", "were", "be", "been",
+        "have", "has", "had", "do", "does", "did", "will", "would", "could",
+        "should", "may", "might", "this", "that", "these", "those", "it", "its",
+        "i", "we", "you", "he", "she", "they", "my", "your", "our", "their",
+        "not", "no", "as", "if", "so", "than", "then", "when", "where", "how",
+        "what", "which", "who",
+    }
+
+    try:
+        df = session.require_data()
+        if col not in df.columns:
+            return f"Column not found: {col}"
+
+        texts = df[col].drop_nulls().cast(pl.Utf8).to_list()
+        all_words = []
+        for text in texts:
+            words = re.findall(r"[a-zA-Z]+", text.lower())
+            if min_len > 1:
+                words = [w for w in words if len(w) >= min_len]
+            if use_stopwords:
+                words = [w for w in words if w not in STOPWORDS]
+            all_words.extend(words)
+
+        if not all_words:
+            return "No words found after filtering."
+
+        counter = Counter(all_words)
+        most_common = counter.most_common(top_n)
+
+        lines = [f"Word Frequency — {col}  (docs={len(texts)}, unique_words={len(counter)})", ""]
+        lines.append(f"  {'Rank':<6} {'Word':<25} {'Count':>8} {'%':>7}")
+        lines.append("  " + "-" * 50)
+        total = len(all_words)
+        for rank, (word, cnt) in enumerate(most_common, 1):
+            lines.append(f"  {rank:<6} {word:<25} {cnt:>8,} {100*cnt/total:>6.2f}%")
+        return "\n".join(lines)
+    except Exception as e:
+        return friendly_error(e, "textfreq")
+
+
+@command("tfidf", usage="tfidf <col> [--top=20] [--max_features=1000]")
+def cmd_tfidf(session: Session, args: str) -> str:
+    """TF-IDF analysis: identify most distinctive terms in a text column.
+
+    Options:
+      --top=<n>              top N terms by mean TF-IDF score (default: 20)
+      --max_features=<n>     vocabulary size limit (default: 1000)
+      --ngram_min=<n>        minimum n-gram size (default: 1)
+      --ngram_max=<n>        maximum n-gram size (default: 1)
+
+    Examples:
+      tfidf review_text --top=30
+      tfidf comments --ngram_min=2 --ngram_max=2 --top=15
+    """
+    try:
+        from sklearn.feature_extraction.text import TfidfVectorizer
+    except ImportError:
+        return "scikit-learn required. Install: pip install scikit-learn"
+
+    import polars as pl
+    import numpy as np
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: tfidf <col> [--top=20]"
+
+    col = ca.positional[0]
+    top_n = int(ca.options.get("top", 20))
+    max_features = int(ca.options.get("max_features", 1000))
+    ngram_min = int(ca.options.get("ngram_min", 1))
+    ngram_max = int(ca.options.get("ngram_max", 1))
+
+    try:
+        df = session.require_data()
+        if col not in df.columns:
+            return f"Column not found: {col}"
+
+        texts = df[col].drop_nulls().cast(pl.Utf8).to_list()
+        if len(texts) < 2:
+            return "Need at least 2 documents for TF-IDF."
+
+        vec = TfidfVectorizer(max_features=max_features, stop_words="english",
+                              ngram_range=(ngram_min, ngram_max))
+        tfidf_matrix = vec.fit_transform(texts)
+        feature_names = vec.get_feature_names_out()
+        mean_scores = np.asarray(tfidf_matrix.mean(axis=0)).flatten()
+        top_idx = mean_scores.argsort()[::-1][:top_n]
+
+        lines = [f"TF-IDF Analysis — {col}  (docs={len(texts)}, vocab={len(feature_names)})", ""]
+        lines.append(f"  {'Rank':<6} {'Term':<30} {'Mean TF-IDF':>12}")
+        lines.append("  " + "-" * 52)
+        for rank, idx in enumerate(top_idx, 1):
+            lines.append(f"  {rank:<6} {feature_names[idx]:<30} {mean_scores[idx]:>12.5f}")
+        return "\n".join(lines)
+    except Exception as e:
+        return friendly_error(e, "tfidf")
+
+
+@command("lda", usage="lda <col> [--topics=5] [--words=10] [--iter=10]")
+def cmd_lda(session: Session, args: str) -> str:
+    """Latent Dirichlet Allocation (LDA) topic modeling.
+
+    Options:
+      --topics=<n>    number of topics (default: 5)
+      --words=<n>     top words per topic to show (default: 10)
+      --iter=<n>      max iterations (default: 10)
+      --max_features=<n>  vocabulary size (default: 1000)
+
+    Examples:
+      lda review_text --topics=5
+      lda abstract --topics=8 --words=12
+    """
+    try:
+        from sklearn.decomposition import LatentDirichletAllocation
+        from sklearn.feature_extraction.text import CountVectorizer
+    except ImportError:
+        return "scikit-learn required. Install: pip install scikit-learn"
+
+    import polars as pl
+    import numpy as np
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: lda <col> [--topics=5]"
+
+    col = ca.positional[0]
+    n_topics = int(ca.options.get("topics", 5))
+    n_words = int(ca.options.get("words", 10))
+    n_iter = int(ca.options.get("iter", 10))
+    max_features = int(ca.options.get("max_features", 1000))
+
+    try:
+        df = session.require_data()
+        if col not in df.columns:
+            return f"Column not found: {col}"
+
+        texts = df[col].drop_nulls().cast(pl.Utf8).to_list()
+        if len(texts) < n_topics:
+            return f"Need at least {n_topics} documents (got {len(texts)})."
+
+        vec = CountVectorizer(max_features=max_features, stop_words="english", min_df=2)
+        dtm = vec.fit_transform(texts)
+        feature_names = vec.get_feature_names_out()
+
+        lda_model = LatentDirichletAllocation(
+            n_components=n_topics, max_iter=n_iter, random_state=42
+        )
+        lda_model.fit(dtm)
+
+        lines = [f"LDA Topic Modeling — {col}  (docs={len(texts)}, topics={n_topics})", ""]
+        for topic_idx, topic in enumerate(lda_model.components_):
+            top_words_idx = topic.argsort()[::-1][:n_words]
+            top_words = [feature_names[i] for i in top_words_idx]
+            lines.append(f"  Topic {topic_idx + 1}: {', '.join(top_words)}")
+        return "\n".join(lines)
+    except Exception as e:
+        return friendly_error(e, "lda")

openstat/commands/ts_adv_cmds.py

@@ -0,0 +1,136 @@
+"""Advanced time-series commands: granger, johansen, vecm, stl, tssmooth."""
+
+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("granger", usage="granger dep cause [maxlag(4)]")
+def cmd_granger(session: Session, args: str) -> str:
+    """Granger causality test."""
+    from openstat.stats.ts_advanced import granger_causality
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if len(positional) < 2:
+        return "Usage: granger dep cause [maxlag(4)]"
+    dep, cause = positional[0], positional[1]
+    maxlag = int(opts.get("maxlag", 4))
+    try:
+        r = granger_causality(df, dep, cause, maxlag=maxlag)
+        lines = [f"\nGranger Causality: {cause} → {dep}", "-" * 50]
+        for lag, pval in r["lag_pvalues"].items():
+            lines.append(f"  Lag {lag:2d}: F-test p-value = {pval:.4f}")
+        lines.append(f"\n  Min p-value: {r['min_pvalue']:.4f} at lag {r['best_lag']}")
+        lines.append(f"  Granger-causes at 5%: {'YES' if r['reject_null_5pct'] else 'NO'}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"granger error: {exc}"
+
+
+@command("johansen", usage="johansen var1 var2 [var3 ...] [lags(1)]")
+def cmd_johansen(session: Session, args: str) -> str:
+    """Johansen cointegration test."""
+    from openstat.stats.ts_advanced import johansen_test
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    cols = [c for c in positional if c in df.columns]
+    if len(cols) < 2:
+        return "johansen requires at least 2 variables."
+    k_ar_diff = int(opts.get("lags", 1))
+    try:
+        r = johansen_test(df, cols, k_ar_diff=k_ar_diff)
+        lines = ["\nJohansen Cointegration Test", "=" * 55]
+        lines.append(f"  Variables: {', '.join(cols)}")
+        lines.append(f"  Cointegrating vectors: {r['n_cointegrating_vectors']}")
+        lines.append("\n  Trace Statistics:")
+        lines.append(f"  {'r=0':>10} {'Statistic':>12} {'CV 95%':>10} {'CV 90%':>10}")
+        for i, (ts, cv95, cv90) in enumerate(zip(r["trace_statistics"], r["trace_cv_95"], r["trace_cv_90"])):
+            lines.append(f"  r<={i:<8} {ts:>12.4f} {cv95:>10.4f} {cv90:>10.4f}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"johansen error: {exc}"
+
+
+@command("vecm", usage="vecm var1 var2 [var3 ...] [lags(1) rank(1)]")
+def cmd_vecm(session: Session, args: str) -> str:
+    """Vector Error Correction Model."""
+    from openstat.stats.ts_advanced import fit_vecm
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    cols = [c for c in positional if c in df.columns]
+    if len(cols) < 2:
+        return "vecm requires at least 2 variables."
+    k_ar_diff = int(opts.get("lags", 1))
+    coint_rank = int(opts.get("rank", 1))
+    try:
+        r = fit_vecm(df, cols, k_ar_diff=k_ar_diff, coint_rank=coint_rank)
+        session._last_model = r
+        lines = ["\nVECM Results", "=" * 50]
+        lines.append(f"  Variables: {', '.join(cols)}")
+        lines.append(f"  Cointegration rank: {coint_rank}, AR lags: {k_ar_diff}")
+        lines.append(f"\n  Alpha (adjustment coefficients):")
+        for row in r["alpha"]:
+            lines.append(f"    {row}")
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"vecm error: {exc}"
+
+
+@command("stl", usage="stl varname [period(12)]")
+def cmd_stl(session: Session, args: str) -> str:
+    """STL decomposition (trend + seasonal + residual)."""
+    from openstat.stats.ts_advanced import stl_decompose
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if not positional:
+        return "Usage: stl varname [period(12)]"
+    col = positional[0]
+    if col not in df.columns:
+        return f"Column '{col}' not found."
+    period = int(opts.get("period", 12))
+    try:
+        r = stl_decompose(df, col, period=period)
+        lines = [f"\nSTL Decomposition: {col} (period={period})", "-" * 45]
+        lines.append(f"  {'Strength of trend':<30} {r['strength_trend']:.4f}")
+        lines.append(f"  {'Strength of seasonal':<30} {r['strength_seasonal']:.4f}")
+        lines.append(f"  Trend range: [{min(r['trend']):.4f}, {max(r['trend']):.4f}]")
+        lines.append(f"  Seasonal range: [{min(r['seasonal']):.4f}, {max(r['seasonal']):.4f}]")
+        session._last_model = r
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"stl error: {exc}"
+
+
+@command("tssmooth", usage="tssmooth varname [method(ma|exp) window(3) alpha(0.3)]")
+def cmd_tssmooth(session: Session, args: str) -> str:
+    """Smooth a time series column."""
+    from openstat.stats.ts_advanced import tssmooth
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if not positional:
+        return "Usage: tssmooth varname [method(ma|exp) window(3) alpha(0.3)]"
+    col = positional[0]
+    if col not in df.columns:
+        return f"Column '{col}' not found."
+    method = opts.get("method", "ma")
+    window = int(opts.get("window", 3))
+    alpha = float(opts.get("alpha", 0.3))
+    session.snapshot()
+    try:
+        session.df = tssmooth(df, col, method=method, window=window, alpha=alpha)
+        new_col = f"{col}_smooth"
+        return f"Smoothed '{col}' → '{new_col}' using {method} (window={window}, alpha={alpha})"
+    except Exception as exc:
+        return f"tssmooth error: {exc}"

openstat/commands/ts_cmds.py

@@ -0,0 +1,195 @@
+"""Time series commands: tsset, arima, var, dfuller, forecast, irf."""
+
+from __future__ import annotations
+
+import re
+
+import numpy as np
+import polars as pl
+from rich.console import Console
+from rich.table import Table
+
+from openstat.session import Session, ModelResult
+from openstat.commands.base import command, CommandArgs, rich_to_str, friendly_error
+from openstat.dsl.parser import parse_formula, ParseError
+
+
+@command("tsset", usage="tsset <time_var> [freq=M|Q|Y|D]")
+def cmd_tsset(session: Session, args: str) -> str:
+    """Declare the time variable for time series analysis."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: tsset <time_var> [freq=M|Q|Y|D]"
+
+    time_var = ca.positional[0]
+    if time_var not in df.columns:
+        return f"Column not found: {time_var}"
+
+    session._time_var = time_var
+    session._ts_freq = ca.get_option("freq")
+    n = df[time_var].n_unique()
+    return f"Time variable: {time_var} ({n} unique values)" + (
+        f"\nFrequency: {session._ts_freq}" if session._ts_freq else ""
+    )
+
+
+@command("dfuller", usage="dfuller <variable>")
+def cmd_dfuller(session: Session, args: str) -> str:
+    """Augmented Dickey-Fuller unit root test."""
+    df = session.require_data()
+    var_name = args.strip()
+    if not var_name:
+        return "Usage: dfuller <variable>"
+    if var_name not in df.columns:
+        return f"Column not found: {var_name}"
+
+    from openstat.stats.timeseries import adf_test
+    series = df[var_name].drop_nulls().to_numpy()
+    return adf_test(series, var_name)
+
+
+@command("arima", usage="arima y [~ x1], order(p,d,q)")
+def cmd_arima(session: Session, args: str) -> str:
+    """Fit ARIMA(p,d,q) or ARIMAX model."""
+    df = session.require_data()
+
+    # Parse order(p,d,q)
+    m = re.search(r'order\((\d+)\s*,\s*(\d+)\s*,\s*(\d+)\)', args)
+    if not m:
+        return "Usage: arima y [~ x1], order(p,d,q)"
+    order = (int(m.group(1)), int(m.group(2)), int(m.group(3)))
+
+    # Remove order(...) from args for formula parsing
+    formula_str = args[:m.start()] + args[m.end():]
+    formula_str = formula_str.strip().rstrip(",").strip()
+
+    # Parse formula
+    if "~" in formula_str:
+        try:
+            dep, exog_vars = parse_formula(formula_str)
+        except ParseError as e:
+            return f"Formula error: {e}"
+    else:
+        parts = formula_str.split()
+        dep = parts[0] if parts else ""
+        exog_vars = None
+
+    if not dep or dep not in df.columns:
+        return f"Dependent variable not found: {dep}"
+
+    try:
+        from openstat.stats.timeseries import fit_arima
+
+        result, raw = fit_arima(df, dep, order, exog_vars, session._time_var)
+
+        session._last_model = raw
+        session._last_model_vars = (dep, exog_vars or [])
+        session._last_fit_result = result
+        session._last_fit_kwargs = {"order": order}
+
+        md = result.to_markdown() if hasattr(result, "to_markdown") else ""
+        session.results.append(ModelResult(
+            name=f"ARIMA{order}", formula=result.formula,
+            table=md, details={
+                "n_obs": result.n_obs,
+                "params": dict(result.params),
+                "aic": result.aic,
+                "bic": result.bic,
+            },
+        ))
+
+        output = result.summary_table()
+        if result.warnings:
+            output += "\n" + "\n".join(result.warnings)
+        return output
+    except Exception as e:
+        return friendly_error(e, "arima")
+
+
+@command("var", usage="var y1 y2 [y3], lags(n)")
+def cmd_var(session: Session, args: str) -> str:
+    """Fit a Vector Autoregression (VAR) model."""
+    df = session.require_data()
+
+    # Parse lags(n)
+    m = re.search(r'lags\((\d+)\)', args)
+    if not m:
+        return "Usage: var y1 y2, lags(n)"
+    lags = int(m.group(1))
+
+    # Parse variable list
+    var_str = args[:m.start()].strip().rstrip(",").strip()
+    variables = var_str.split()
+    if len(variables) < 2:
+        return "VAR requires at least 2 variables."
+
+    missing = [v for v in variables if v not in df.columns]
+    if missing:
+        return f"Columns not found: {', '.join(missing)}"
+
+    try:
+        from openstat.stats.timeseries import fit_var
+
+        summary, raw = fit_var(df, variables, lags, session._time_var)
+
+        session._last_model = raw
+        session._last_model_vars = (variables[0], variables[1:])
+        session._last_fit_kwargs = {"lags": lags, "variables": variables}
+
+        session.results.append(ModelResult(
+            name=f"VAR({lags})", formula=f"VAR({', '.join(variables)})",
+            table=summary, details={"lags": lags, "variables": variables},
+        ))
+
+        return summary
+    except Exception as e:
+        return friendly_error(e, "var")
+
+
+@command("forecast", usage="forecast <steps>")
+def cmd_forecast(session: Session, args: str) -> str:
+    """Generate forecasts from the last fitted time series model."""
+    if session._last_model is None:
+        return "No model fitted. Run arima or var first."
+
+    steps = int(args.strip()) if args.strip().isdigit() else 12
+
+    try:
+        from openstat.stats.timeseries import forecast_model
+        fc = forecast_model(session._last_model, steps)
+
+        def render(console: Console) -> None:
+            table = Table(title=f"Forecast ({steps} steps)")
+            table.add_column("Step", justify="right")
+            if fc.ndim == 1:
+                table.add_column("Forecast", justify="right")
+                for i, val in enumerate(fc, 1):
+                    table.add_row(str(i), f"{val:.4f}")
+            else:
+                vars_list = session._last_fit_kwargs.get("variables", [])
+                for v in vars_list:
+                    table.add_column(v, justify="right")
+                for i, row in enumerate(fc, 1):
+                    table.add_row(str(i), *[f"{v:.4f}" for v in row])
+            console.print(table)
+
+        return rich_to_str(render)
+    except Exception as e:
+        return friendly_error(e, "forecast")
+
+
+@command("irf", usage="irf [steps=N]")
+def cmd_irf(session: Session, args: str) -> str:
+    """Impulse response functions for VAR model."""
+    if session._last_model is None:
+        return "No model fitted. Run var first."
+
+    ca = CommandArgs(args)
+    steps = int(ca.get_option("steps", "10"))
+
+    try:
+        from openstat.stats.timeseries import compute_irf
+        return compute_irf(session._last_model, steps)
+    except Exception as e:
+        return friendly_error(e, "irf")

openstat/commands/tui_cmds.py

@@ -0,0 +1,111 @@
+"""TUI dashboard command: dashboard (requires textual)."""
+
+from __future__ import annotations
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+@command("dashboard", usage="dashboard")
+def cmd_dashboard(session: Session, args: str) -> str:
+    """Launch an interactive TUI dashboard (requires: pip install textual).
+
+    Shows dataset overview, variable list, model results, and recent history
+    in a full-screen terminal UI. Press Q or Ctrl+C to exit.
+    """
+    try:
+        from textual.app import App, ComposeResult
+        from textual.widgets import (
+            DataTable, Footer, Header, Label, RichLog, TabbedContent, TabPane,
+        )
+        from textual.binding import Binding
+    except ImportError:
+        return (
+            "textual is required for the dashboard.\n"
+            "Install: pip install textual"
+        )
+
+    import polars as pl
+
+    # ── Snapshot data so the TUI doesn't need the live session ──────────────
+    dataset_name = session.dataset_name or "(no dataset)"
+    shape_str = session.shape_str
+    df = session.df
+    results = list(session.results)
+    history = list(session.history[-50:])  # last 50 commands
+
+    # Build column summary
+    col_rows: list[tuple[str, ...]] = []
+    if df is not None:
+        NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+                   pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+        for c in df.columns:
+            dtype = str(df[c].dtype)
+            n_miss = str(df[c].null_count())
+            if df[c].dtype in NUMERIC:
+                col_data = df[c].drop_nulls()
+                if col_data.len() > 0:
+                    mean_str = f"{col_data.mean():.3f}"
+                    sd_str = f"{col_data.std():.3f}" if col_data.len() > 1 else "—"
+                else:
+                    mean_str = sd_str = "—"
+            else:
+                mean_str = sd_str = "—"
+            col_rows.append((c, dtype, n_miss, mean_str, sd_str))
+
+    class OpenStatDashboard(App):
+        TITLE = f"OpenStat Dashboard — {dataset_name}"
+        BINDINGS = [
+            Binding("q", "quit", "Quit"),
+            Binding("ctrl+c", "quit", "Quit"),
+        ]
+        CSS = """
+        Screen { background: #1a1a2e; }
+        Header { background: #16213e; color: #e94560; }
+        Footer { background: #16213e; color: #a8b2d8; }
+        TabbedContent { background: #1a1a2e; }
+        TabPane { padding: 1 2; }
+        DataTable { height: auto; }
+        Label { color: #cdd6f4; margin: 0 0 1 0; }
+        RichLog { height: 30; border: solid #313244; background: #181825; }
+        """
+
+        def compose(self) -> ComposeResult:
+            yield Header()
+            with TabbedContent():
+                with TabPane("Overview", id="overview"):
+                    yield Label(f"[bold]Dataset:[/bold] {dataset_name}  |  [bold]Shape:[/bold] {shape_str}")
+                    yield Label(
+                        f"[bold]Models fitted:[/bold] {len(results)}  |  "
+                        f"[bold]Commands run:[/bold] {len(session.history)}"
+                    )
+
+                with TabPane("Variables", id="variables"):
+                    tbl = DataTable(zebra_stripes=True)
+                    tbl.add_columns("Variable", "Type", "Missing", "Mean", "SD")
+                    for row in col_rows:
+                        tbl.add_row(*row)
+                    yield tbl
+
+                with TabPane("Models", id="models"):
+                    if results:
+                        log = RichLog(markup=True, highlight=True)
+                        for mr in results:
+                            log.write(f"[bold cyan]{mr.name}: {mr.formula}[/bold cyan]")
+                            log.write(mr.table)
+                            log.write("")
+                        yield log
+                    else:
+                        yield Label("No models fitted yet.")
+
+                with TabPane("History", id="history"):
+                    log = RichLog(markup=False, highlight=False)
+                    for cmd_line in history:
+                        log.write(f". {cmd_line}")
+                    yield log
+
+            yield Footer()
+
+    app = OpenStatDashboard()
+    app.run()
+    return "Dashboard closed."