openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/dataquality_cmds.py

@@ -0,0 +1,174 @@
+"""Data quality commands: duplicates, winsor, standardize, normalize, mdpattern."""
+
+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("duplicates", usage="duplicates [report|drop] [varlist]")
+def cmd_duplicates(session: Session, args: str) -> str:
+    """Report or drop duplicate observations."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    action = positional[0].lower() if positional else "report"
+    subset = [c for c in positional[1:] if c in df.columns] or None
+
+    if action == "report":
+        if subset:
+            dup_mask = df.select(subset).is_duplicated()
+        else:
+            dup_mask = df.is_duplicated()
+        n_dup = int(dup_mask.sum())
+        n_unique_dup = int(df.filter(dup_mask).height) - int(df.filter(dup_mask).unique(subset=subset).height) if n_dup > 0 else 0
+        return (
+            f"Duplicates report:\n"
+            f"  Total observations:    {df.height}\n"
+            f"  Duplicate rows:        {n_dup}\n"
+            f"  Unique duplicated obs: {n_unique_dup}\n"
+            f"  Subset: {subset or 'all columns'}"
+        )
+    elif action in ("drop", "list"):
+        session.snapshot()
+        if subset:
+            clean_df = df.unique(subset=subset, keep="first")
+        else:
+            clean_df = df.unique(keep="first")
+        n_dropped = df.height - clean_df.height
+        if action == "drop":
+            session.df = clean_df
+            return f"Dropped {n_dropped} duplicate rows. {clean_df.height} rows remain."
+        else:
+            return f"Found {n_dropped} duplicate rows (use 'duplicates drop' to remove)."
+    else:
+        return "Usage: duplicates [report|drop|list] [varlist]"
+
+
+@command("winsor", usage="winsor varname [p(0.05) gen(newvar)]")
+def cmd_winsor(session: Session, args: str) -> str:
+    """Winsorize a variable at specified percentile (both tails)."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if not positional:
+        return "Usage: winsor varname [p(0.05) gen(newvar)]"
+    var = positional[0]
+    if var not in df.columns:
+        return f"Column '{var}' not found."
+    p = float(opts.get("p", 0.05))
+    new_var = opts.get("gen", f"{var}_w")
+    session.snapshot()
+    try:
+        series = df[var].cast(pl.Float64)
+        lo = float(series.quantile(p))
+        hi = float(series.quantile(1 - p))
+        winsorized = series.clip(lo, hi)
+        session.df = df.with_columns(winsorized.alias(new_var))
+        n_lo = int((series < lo).sum())
+        n_hi = int((series > hi).sum())
+        return (
+            f"Winsorized '{var}' → '{new_var}'\n"
+            f"  Lower cutoff ({p*100:.1f}%): {lo:.4f}  ({n_lo} obs clipped)\n"
+            f"  Upper cutoff ({(1-p)*100:.1f}%): {hi:.4f}  ({n_hi} obs clipped)"
+        )
+    except Exception as exc:
+        return f"winsor error: {exc}"
+
+
+@command("standardize", usage="standardize var1 [var2 ...] [gen(prefix_)]")
+def cmd_standardize(session: Session, args: str) -> str:
+    """Z-score standardize variables: (x - mean) / std."""
+    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."
+    prefix = opts.get("gen", "")
+    session.snapshot()
+    try:
+        new_df = df
+        new_cols = []
+        for col in cols:
+            s = df[col].cast(pl.Float64)
+            m = float(s.mean())
+            sd = float(s.std())
+            new_name = f"{prefix}{col}_z" if not prefix else f"{prefix}{col}"
+            new_df = new_df.with_columns(((s - m) / max(sd, 1e-10)).alias(new_name))
+            new_cols.append(new_name)
+        session.df = new_df
+        return f"Standardized {len(cols)} variable(s): {new_cols}"
+    except Exception as exc:
+        return f"standardize error: {exc}"
+
+
+@command("normalize", usage="normalize var1 [var2 ...] [gen(prefix_)]")
+def cmd_normalize(session: Session, args: str) -> str:
+    """Min-max normalize variables to [0, 1]."""
+    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."
+    prefix = opts.get("gen", "")
+    session.snapshot()
+    try:
+        new_df = df
+        new_cols = []
+        for col in cols:
+            s = df[col].cast(pl.Float64)
+            lo = float(s.min())
+            hi = float(s.max())
+            new_name = f"{prefix}{col}_norm" if not prefix else f"{prefix}{col}"
+            new_df = new_df.with_columns(((s - lo) / max(hi - lo, 1e-10)).alias(new_name))
+            new_cols.append(new_name)
+        session.df = new_df
+        return f"Normalized {len(cols)} variable(s) to [0,1]: {new_cols}"
+    except Exception as exc:
+        return f"normalize error: {exc}"
+
+
+@command("mdpattern", usage="mdpattern [var1 var2 ...]")
+def cmd_mdpattern(session: Session, args: str) -> str:
+    """Display missing data pattern for all (or specified) variables."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    cols = [c for c in positional if c in df.columns] or df.columns
+
+    lines = ["\nMissing Data Pattern", "=" * 60]
+    lines.append(f"  N = {df.height} observations, {len(cols)} variables\n")
+
+    col_w = max(len(c) for c in cols) + 2
+    header = f"  {'Variable':<{col_w}} {'Missing':>8} {'%Missing':>10} {'Complete':>10}"
+    lines.append(header)
+    lines.append("  " + "-" * (col_w + 32))
+
+    total_missing = 0
+    for col in cols:
+        n_miss = int(df[col].is_null().sum())
+        pct = 100.0 * n_miss / df.height if df.height > 0 else 0.0
+        n_complete = df.height - n_miss
+        total_missing += n_miss
+        bar = "░" * int(pct / 5)  # bar in 5% increments
+        lines.append(f"  {col:<{col_w}} {n_miss:>8} {pct:>9.1f}% {n_complete:>10}  {bar}")
+
+    lines.append("  " + "-" * (col_w + 32))
+    overall_pct = 100.0 * total_missing / (df.height * len(cols)) if df.height > 0 else 0.0
+    lines.append(f"  {'Total missing cells':<{col_w}} {total_missing:>8} {overall_pct:>9.1f}%")
+
+    # Complete cases
+    n_complete_rows = int(df.select(cols).drop_nulls().height)
+    lines.append(f"\n  Complete rows (no missing in any selected var): {n_complete_rows} ({100*n_complete_rows/df.height:.1f}%)")
+
+    return "\n".join(lines)

openstat/commands/datetime_cmds.py

@@ -0,0 +1,176 @@
+"""Datetime operations: extract, arithmetic, format."""
+
+from __future__ import annotations
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("datetime", usage="datetime extract|diff|format|parse <col> [options]")
+def cmd_datetime(session: Session, args: str) -> str:
+    """Datetime column operations.
+
+    Sub-commands:
+      datetime extract <col> [into(<prefix>)]
+          — extract year, month, day, hour, minute, weekday, quarter
+      datetime diff <col1> <col2> [unit=days|hours|minutes] [into(<newcol>)]
+          — compute difference between two date columns
+      datetime format <col> <fmt> [into(<newcol>)]
+          — reformat datetime as string (strftime format)
+      datetime parse <col> [fmt=<format>] [into(<newcol>)]
+          — parse a string column as datetime
+      datetime shift <col> <N> <unit> [into(<newcol>)]
+          — add/subtract time (e.g. shift date 7 days)
+
+    Examples:
+      datetime extract created_at into(dt)
+        → creates dt_year, dt_month, dt_day, dt_weekday, dt_quarter
+      datetime diff end_date start_date unit=days into(duration)
+      datetime format created_at "%Y-%m" into(year_month)
+      datetime parse date_str fmt="%d/%m/%Y" into(date)
+      datetime shift order_date 30 days into(delivery_date)
+    """
+    import polars as pl
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: datetime extract|diff|format|parse|shift <col> ..."
+
+    subcmd = ca.positional[0].lower()
+
+    try:
+        df = session.require_data()
+
+        if subcmd == "extract":
+            if len(ca.positional) < 2:
+                return "Usage: datetime extract <col> [into(<prefix>)]"
+            col = ca.positional[1]
+            if col not in df.columns:
+                return f"Column not found: {col}"
+
+            into_raw = ca.rest_after("into")
+            prefix = into_raw.strip().strip("()") if into_raw else col
+
+            # Cast to datetime if string
+            series = df[col]
+            if series.dtype == pl.Utf8:
+                series = series.str.to_datetime(strict=False)
+
+            dt = series.dt
+            new_cols = {
+                f"{prefix}_year": dt.year(),
+                f"{prefix}_month": dt.month(),
+                f"{prefix}_day": dt.day(),
+                f"{prefix}_hour": dt.hour(),
+                f"{prefix}_minute": dt.minute(),
+                f"{prefix}_weekday": dt.weekday(),
+                f"{prefix}_quarter": dt.quarter(),
+            }
+            session.snapshot()
+            session.df = df.with_columns([
+                pl.Series(name, vals) for name, vals in new_cols.items()
+            ])
+            parts = ", ".join(new_cols.keys())
+            return f"Extracted datetime components: {parts}"
+
+        elif subcmd == "diff":
+            if len(ca.positional) < 3:
+                return "Usage: datetime diff <col1> <col2> [unit=days] [into(<newcol>)]"
+            c1, c2 = ca.positional[1], ca.positional[2]
+            unit = ca.options.get("unit", "days")
+            into_raw = ca.rest_after("into")
+            newcol = into_raw.strip().strip("()") if into_raw else f"{c1}_minus_{c2}"
+
+            for c in [c1, c2]:
+                if c not in df.columns:
+                    return f"Column not found: {c}"
+
+            def _to_dt(s):
+                if s.dtype == pl.Utf8:
+                    return s.str.to_datetime(strict=False)
+                return s.cast(pl.Datetime)
+
+            s1 = _to_dt(df[c1])
+            s2 = _to_dt(df[c2])
+            diff_dur = s1 - s2
+
+            unit_map = {
+                "days": 86_400_000_000,
+                "hours": 3_600_000_000,
+                "minutes": 60_000_000,
+                "seconds": 1_000_000,
+            }
+            divisor = unit_map.get(unit, 86_400_000_000)
+            diff_num = (diff_dur.dt.total_microseconds() / divisor).cast(pl.Float64)
+
+            session.snapshot()
+            session.df = df.with_columns(diff_num.alias(newcol))
+            return f"Date difference stored in '{newcol}' ({unit}). Mean: {diff_num.mean():.2f}"
+
+        elif subcmd == "format":
+            if len(ca.positional) < 3:
+                return "Usage: datetime format <col> <fmt> [into(<newcol>)]"
+            col, fmt = ca.positional[1], ca.positional[2]
+            if col not in df.columns:
+                return f"Column not found: {col}"
+            into_raw = ca.rest_after("into")
+            newcol = into_raw.strip().strip("()") if into_raw else f"{col}_fmt"
+
+            series = df[col]
+            if series.dtype == pl.Utf8:
+                series = series.str.to_datetime(strict=False)
+            formatted = series.dt.strftime(fmt)
+
+            session.snapshot()
+            session.df = df.with_columns(formatted.alias(newcol))
+            return f"Formatted '{col}' → '{newcol}' using format '{fmt}'"
+
+        elif subcmd == "parse":
+            if len(ca.positional) < 2:
+                return "Usage: datetime parse <col> [fmt=<format>] [into(<newcol>)]"
+            col = ca.positional[1]
+            if col not in df.columns:
+                return f"Column not found: {col}"
+            fmt = ca.options.get("fmt")
+            into_raw = ca.rest_after("into")
+            newcol = into_raw.strip().strip("()") if into_raw else f"{col}_dt"
+
+            if fmt:
+                parsed = df[col].str.to_datetime(format=fmt, strict=False)
+            else:
+                parsed = df[col].str.to_datetime(strict=False)
+
+            session.snapshot()
+            session.df = df.with_columns(parsed.alias(newcol))
+            n_ok = parsed.drop_nulls().len()
+            return f"Parsed '{col}' → '{newcol}': {n_ok}/{df.height} rows parsed."
+
+        elif subcmd == "shift":
+            if len(ca.positional) < 4:
+                return "Usage: datetime shift <col> <N> <unit> [into(<newcol>)]"
+            col = ca.positional[1]
+            n = int(ca.positional[2])
+            unit = ca.positional[3].lower().rstrip("s")  # days→day, hours→hour
+            if col not in df.columns:
+                return f"Column not found: {col}"
+            into_raw = ca.rest_after("into")
+            newcol = into_raw.strip().strip("()") if into_raw else f"{col}_shifted"
+
+            series = df[col]
+            if series.dtype == pl.Utf8:
+                series = series.str.to_datetime(strict=False)
+
+            from datetime import timedelta
+            unit_map2 = {"day": "days", "hour": "hours", "minute": "minutes", "second": "seconds", "week": "weeks"}
+            td_key = unit_map2.get(unit, "days")
+            shifted = series + pl.duration(**{td_key: n})
+
+            session.snapshot()
+            session.df = df.with_columns(shifted.alias(newcol))
+            return f"Shifted '{col}' by {n} {unit}(s) → '{newcol}'"
+
+        else:
+            return f"Unknown sub-command: {subcmd}. Use extract, diff, format, parse, or shift."
+
+    except Exception as e:
+        return friendly_error(e, "datetime")

openstat/commands/dimreduce_cmds.py

@@ -0,0 +1,184 @@
+"""Dimensionality reduction: t-SNE, UMAP, PCA plot."""
+
+from __future__ import annotations
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("tsne", usage="tsne [cols...] [--n=2] [--perplexity=30] [--out=tsne.png] [--color=col]")
+def cmd_tsne(session: Session, args: str) -> str:
+    """t-SNE dimensionality reduction and visualization.
+
+    Options:
+      --n=<dim>          output dimensions (2 or 3, default: 2)
+      --perplexity=<p>   perplexity (5–50, default: 30)
+      --iter=<n>         iterations (default: 1000)
+      --color=<col>      column to colour points by
+      --out=<path>       output image path
+
+    Examples:
+      tsne x1 x2 x3 x4 --color=label
+      tsne --perplexity=20 --iter=2000 --out=tsne_result.png
+    """
+    try:
+        from sklearn.manifold import TSNE
+    except ImportError:
+        return "scikit-learn required. Install: pip install scikit-learn"
+
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    import numpy as np
+    import polars as pl
+
+    ca = CommandArgs(args)
+    n_dim = int(ca.options.get("n", 2))
+    perplexity = float(ca.options.get("perplexity", 30))
+    n_iter = int(ca.options.get("iter", 1000))
+    color_col = ca.options.get("color")
+    out_path = ca.options.get("out", str(session.output_dir / "tsne.png"))
+
+    try:
+        df = session.require_data()
+        NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+                   pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+        if ca.positional:
+            cols = [c for c in ca.positional if c in df.columns]
+        else:
+            cols = [c for c in df.columns if df[c].dtype in NUMERIC]
+
+        if len(cols) < 2:
+            return "Need at least 2 numeric columns for t-SNE."
+
+        sub_cols = cols[:]
+        if color_col and color_col in df.columns and color_col not in sub_cols:
+            sub_cols.append(color_col)
+
+        sub = df.select(sub_cols).drop_nulls()
+        X = sub.select(cols).to_numpy().astype(float)
+
+        if len(X) < 5:
+            return "Need at least 5 rows for t-SNE."
+
+        perplexity = min(perplexity, len(X) - 1)
+        tsne = TSNE(n_components=n_dim, perplexity=perplexity, max_iter=n_iter,
+                    random_state=42)
+        embedding = tsne.fit_transform(X)
+
+        fig, ax = plt.subplots(figsize=(8, 6))
+        if color_col and color_col in sub.columns:
+            cats = sub[color_col].cast(pl.Utf8).to_list()
+            unique_cats = sorted(set(cats))
+            cmap = plt.colormaps.get_cmap("tab10")
+            for i, cat in enumerate(unique_cats):
+                mask = [c == cat for c in cats]
+                ax.scatter(embedding[mask, 0], embedding[mask, 1],
+                           label=str(cat), alpha=0.7, s=20,
+                           color=cmap(i / max(len(unique_cats), 1)))
+            ax.legend(title=color_col, markerscale=2, fontsize=8)
+        else:
+            ax.scatter(embedding[:, 0], embedding[:, 1], alpha=0.6, s=20, color="#4C72B0")
+
+        ax.set_xlabel("t-SNE 1")
+        ax.set_ylabel("t-SNE 2")
+        ax.set_title(f"t-SNE ({len(cols)} features, perplexity={perplexity:.0f})")
+        fig.tight_layout()
+
+        session.output_dir.mkdir(parents=True, exist_ok=True)
+        from pathlib import Path
+        Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+        fig.savefig(out_path, dpi=150)
+        plt.close(fig)
+        session.plot_paths.append(out_path)
+        return f"t-SNE plot saved: {out_path}  (n={len(X)}, features={len(cols)})"
+    except Exception as e:
+        return friendly_error(e, "tsne")
+
+
+@command("umap", usage="umap [cols...] [--n=2] [--neighbors=15] [--out=umap.png] [--color=col]")
+def cmd_umap(session: Session, args: str) -> str:
+    """UMAP dimensionality reduction and visualization.
+
+    Options:
+      --n=<dim>          output dimensions (2 or 3, default: 2)
+      --neighbors=<k>    number of neighbors (default: 15)
+      --mindist=<d>      minimum distance (default: 0.1)
+      --color=<col>      column to colour points by
+      --out=<path>       output image path
+
+    Examples:
+      umap x1 x2 x3 x4 --color=label
+      umap --neighbors=20 --mindist=0.05
+    """
+    try:
+        import umap as umap_lib
+    except ImportError:
+        return "umap-learn required. Install: pip install umap-learn"
+
+    import matplotlib
+    matplotlib.use("Agg")
+    import matplotlib.pyplot as plt
+    import polars as pl
+
+    ca = CommandArgs(args)
+    n_dim = int(ca.options.get("n", 2))
+    n_neighbors = int(ca.options.get("neighbors", 15))
+    min_dist = float(ca.options.get("mindist", 0.1))
+    color_col = ca.options.get("color")
+    out_path = ca.options.get("out", str(session.output_dir / "umap.png"))
+
+    try:
+        df = session.require_data()
+        NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+                   pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+        if ca.positional:
+            cols = [c for c in ca.positional if c in df.columns]
+        else:
+            cols = [c for c in df.columns if df[c].dtype in NUMERIC]
+
+        if len(cols) < 2:
+            return "Need at least 2 numeric columns for UMAP."
+
+        sub_cols = cols[:]
+        if color_col and color_col in df.columns and color_col not in sub_cols:
+            sub_cols.append(color_col)
+
+        sub = df.select(sub_cols).drop_nulls()
+        X = sub.select(cols).to_numpy().astype(float)
+
+        if len(X) < 4:
+            return "Need at least 4 rows for UMAP."
+
+        n_neighbors = min(n_neighbors, len(X) - 1)
+        reducer = umap_lib.UMAP(n_components=n_dim, n_neighbors=n_neighbors,
+                                min_dist=min_dist, random_state=42)
+        embedding = reducer.fit_transform(X)
+
+        fig, ax = plt.subplots(figsize=(8, 6))
+        if color_col and color_col in sub.columns:
+            cats = sub[color_col].cast(pl.Utf8).to_list()
+            unique_cats = sorted(set(cats))
+            cmap = plt.colormaps.get_cmap("tab10")
+            for i, cat in enumerate(unique_cats):
+                mask = [c == cat for c in cats]
+                ax.scatter(embedding[mask, 0], embedding[mask, 1],
+                           label=str(cat), alpha=0.7, s=20,
+                           color=cmap(i / max(len(unique_cats), 1)))
+            ax.legend(title=color_col, markerscale=2, fontsize=8)
+        else:
+            ax.scatter(embedding[:, 0], embedding[:, 1], alpha=0.6, s=20, color="#4C72B0")
+
+        ax.set_xlabel("UMAP 1")
+        ax.set_ylabel("UMAP 2")
+        ax.set_title(f"UMAP ({len(cols)} features, neighbors={n_neighbors})")
+        fig.tight_layout()
+
+        session.output_dir.mkdir(parents=True, exist_ok=True)
+        from pathlib import Path
+        Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+        fig.savefig(out_path, dpi=150)
+        plt.close(fig)
+        session.plot_paths.append(out_path)
+        return f"UMAP plot saved: {out_path}  (n={len(X)}, features={len(cols)})"
+    except Exception as e:
+        return friendly_error(e, "umap")

openstat/commands/discrete_cmds.py

@@ -0,0 +1,149 @@
+"""Discrete / censored model commands: tobit, mlogit, ologit, oprobit."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.session import Session, ModelResult
+from openstat.dsl.parser import parse_formula, ParseError
+from openstat.stats.discrete import fit_tobit, fit_mlogit, fit_ordered
+from openstat.commands.base import command, CommandArgs, friendly_error
+
+
+def _store_model(session, result, raw_model, dep, indeps):
+    """Store model in session state, return summary output."""
+    session._last_model = raw_model
+    session._last_model_vars = (dep, indeps)
+    session._last_fit_result = result
+    session._last_fit_kwargs = {}
+    md = result.to_markdown()
+    details: dict = {
+        "n_obs": result.n_obs,
+        "params": dict(result.params),
+        "std_errors": dict(result.std_errors),
+    }
+    if result.aic is not None:
+        details["aic"] = result.aic
+    if result.bic is not None:
+        details["bic"] = result.bic
+    if result.pseudo_r2 is not None:
+        details["pseudo_r2"] = result.pseudo_r2
+    if result.log_likelihood is not None:
+        details["log_likelihood"] = result.log_likelihood
+    session.results.append(ModelResult(
+        name=result.model_type, formula=result.formula,
+        table=md, details=details,
+    ))
+    output = result.summary_table()
+    if result.warnings:
+        output += "\n" + "\n".join(result.warnings)
+    return output
+
+
+@command("tobit", usage="tobit y ~ x1 + x2 [, ll(0)] [, ul(100)] [--robust]")
+def cmd_tobit(session: Session, args: str) -> str:
+    """Fit a Tobit (censored) regression model."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+    robust = ca.has_flag("--robust")
+    cluster_col = ca.get_option("cluster")
+
+    # Parse limits from args: ll(value) and ul(value)
+    lower_limit = None
+    upper_limit = None
+    ll_match = re.search(r'(?:,\s*)?ll\(([^)]+)\)', args)
+    ul_match = re.search(r'(?:,\s*)?ul\(([^)]+)\)', args)
+    if ll_match:
+        try:
+            lower_limit = float(ll_match.group(1))
+        except ValueError:
+            return f"Invalid lower limit: {ll_match.group(1)}"
+    if ul_match:
+        try:
+            upper_limit = float(ul_match.group(1))
+        except ValueError:
+            return f"Invalid upper limit: {ul_match.group(1)}"
+
+    # Strip limit specs from formula
+    formula_str = args
+    for pattern in [r',?\s*ll\([^)]+\)', r',?\s*ul\([^)]+\)']:
+        formula_str = re.sub(pattern, '', formula_str)
+    formula_str = CommandArgs(formula_str).strip_flags_and_options()
+
+    if not formula_str or "~" not in formula_str:
+        return "Usage: tobit y ~ x1 + x2 [, ll(0)] [, ul(100)] [--robust]"
+
+    try:
+        dep, indeps = parse_formula(formula_str)
+        result, raw_model = fit_tobit(
+            df, dep, indeps,
+            lower_limit=lower_limit,
+            upper_limit=upper_limit,
+            robust=robust,
+            cluster_col=cluster_col,
+        )
+        return _store_model(session, result, raw_model, dep, indeps)
+    except ParseError as e:
+        return f"Formula error: {e}"
+    except Exception as e:
+        return friendly_error(e, "Tobit error")
+
+
+@command("mlogit", usage="mlogit y ~ x1 + x2 [--robust] [--cluster=col]")
+def cmd_mlogit(session: Session, args: str) -> str:
+    """Fit a Multinomial Logit model."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+    robust = ca.has_flag("--robust")
+    cluster_col = ca.get_option("cluster")
+    formula_str = ca.strip_flags_and_options()
+    if not formula_str:
+        return "Usage: mlogit y ~ x1 + x2 [--robust] [--cluster=col]"
+    try:
+        dep, indeps = parse_formula(formula_str)
+        result, raw_model = fit_mlogit(df, dep, indeps, robust=robust, cluster_col=cluster_col)
+        return _store_model(session, result, raw_model, dep, indeps)
+    except ParseError as e:
+        return f"Formula error: {e}"
+    except Exception as e:
+        return friendly_error(e, "MNLogit error")
+
+
+@command("ologit", usage="ologit y ~ x1 + x2 [--robust]")
+def cmd_ologit(session: Session, args: str) -> str:
+    """Fit an Ordered Logit model."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+    robust = ca.has_flag("--robust")
+    cluster_col = ca.get_option("cluster")
+    formula_str = ca.strip_flags_and_options()
+    if not formula_str:
+        return "Usage: ologit y ~ x1 + x2 [--robust]"
+    try:
+        dep, indeps = parse_formula(formula_str)
+        result, raw_model = fit_ordered(df, dep, indeps, link="logit", robust=robust, cluster_col=cluster_col)
+        return _store_model(session, result, raw_model, dep, indeps)
+    except ParseError as e:
+        return f"Formula error: {e}"
+    except Exception as e:
+        return friendly_error(e, "Ordered Logit error")
+
+
+@command("oprobit", usage="oprobit y ~ x1 + x2 [--robust]")
+def cmd_oprobit(session: Session, args: str) -> str:
+    """Fit an Ordered Probit model."""
+    df = session.require_data()
+    ca = CommandArgs(args)
+    robust = ca.has_flag("--robust")
+    cluster_col = ca.get_option("cluster")
+    formula_str = ca.strip_flags_and_options()
+    if not formula_str:
+        return "Usage: oprobit y ~ x1 + x2 [--robust]"
+    try:
+        dep, indeps = parse_formula(formula_str)
+        result, raw_model = fit_ordered(df, dep, indeps, link="probit", robust=robust, cluster_col=cluster_col)
+        return _store_model(session, result, raw_model, dep, indeps)
+    except ParseError as e:
+        return f"Formula error: {e}"
+    except Exception as e:
+        return friendly_error(e, "Ordered Probit error")