openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/advreg_cmds.py

@@ -0,0 +1,207 @@
+"""Advanced regression commands: nls, betareg, zip, zinb, hurdle, sureg."""
+
+from __future__ import annotations
+import re
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+def _parse_eq(args: str, df_cols: list[str]) -> tuple[str, list[str], dict]:
+    positional, opts = _stata_opts(args)
+    dep = positional[0] if positional else ""
+    indeps = [c for c in positional[1:] if c in df_cols]
+    return dep, indeps, opts
+
+
+def _coef_table(params: dict, se: dict = None, pvals: dict = None) -> str:
+    lines = [f"  {'Variable':<22}  {'Coef.':>10}"]
+    if se:
+        lines[0] += f"  {'Std.Err.':>10}"
+    if pvals:
+        lines[0] += f"  {'p-value':>8}"
+    lines.append("  " + "-" * 55)
+    for k, v in params.items():
+        row = f"  {k:<22}  {v:>10.4f}"
+        if se and k in se:
+            row += f"  {se[k]:>10.4f}"
+        if pvals and k in pvals:
+            row += f"  {pvals[k]:>8.4f}"
+        lines.append(row)
+    return "\n".join(lines)
+
+
+@command("nls", usage="nls depvar indepvars [, p0(a,b,c) fn(power|exp|log)]")
+def cmd_nls(session: Session, args: str) -> str:
+    """Nonlinear least squares with built-in functional forms."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_eq(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: nls depvar indepvar1 ... [, fn(power) p0(1,1)]"
+
+    fn_name = opts.get("fn", "power")
+    p0_raw = opts.get("p0", "1,1")
+    try:
+        p0 = [float(x) for x in p0_raw.split(",")]
+    except ValueError:
+        p0 = [1.0, 1.0]
+
+    built_in = {
+        "power": lambda X, a, b: a * X[:, 0] ** b,
+        "exp": lambda X, a, b: a * np.exp(b * X[:, 0]),
+        "log": lambda X, a, b: a + b * np.log(np.maximum(X[:, 0], 1e-15)),
+    }
+
+    import numpy as np
+    fn = built_in.get(fn_name)
+    if fn is None:
+        return f"Unknown function '{fn_name}'. Use: power, exp, log"
+
+    # Adjust p0 to match function arity
+    import inspect
+    n_params = len(inspect.signature(fn).parameters) - 1
+    p0 = (p0 + [1.0] * n_params)[:n_params]
+
+    try:
+        from openstat.stats.advanced_regression import fit_nls
+        result = fit_nls(df, dep, indeps, fn, p0)
+        session._last_model = result
+        lines = [f"\nNLS ({fn_name}): {dep}", "=" * 50]
+        lines.append(f"  {'N obs':<22}  {result['n_obs']:>10}")
+        lines.append(f"  {'R²':<22}  {result['r_squared']:>10.4f}")
+        lines.append(f"  {'Converged':<22}  {result['converged']!s:>10}")
+        lines.append("\nParameters:")
+        lines.append(_coef_table(result["params"], result["std_errors"]))
+        lines.append("=" * 50)
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"nls error: {exc}"
+
+
+@command("betareg", usage="betareg depvar indepvars")
+def cmd_betareg(session: Session, args: str) -> str:
+    """Beta regression for (0,1) bounded outcomes."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_eq(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: betareg depvar indepvar1 ..."
+    try:
+        from openstat.stats.advanced_regression import fit_betareg
+        result = fit_betareg(df, dep, indeps)
+        session._last_model = result
+        lines = [f"\n{result['method']}: {dep}", "=" * 55]
+        lines.append(f"  N = {result['n_obs']}   AIC = {result['aic']:.4f}   Pseudo-R² = {result['pseudo_r2']:.4f}")
+        lines.append("\nCoefficients:")
+        lines.append(_coef_table(result["params"], result["std_errors"], result["p_values"]))
+        lines.append("=" * 55)
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"betareg error: {exc}"
+
+
+@command("zip", usage="zip depvar indepvars")
+def cmd_zip(session: Session, args: str) -> str:
+    """Zero-Inflated Poisson regression."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_eq(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: zip depvar indepvar1 ..."
+    try:
+        from openstat.stats.advanced_regression import fit_zip
+        result = fit_zip(df, dep, indeps)
+        session._last_model = result
+        lines = [f"\n{result['method']}: {dep}", "=" * 55]
+        lines.append(f"  N = {result['n_obs']}   AIC = {result['aic']:.4f}   LL = {result['log_likelihood']:.4f}")
+        lines.append("\nCoefficients:")
+        lines.append(_coef_table(result["params"], result["std_errors"], result["p_values"]))
+        lines.append("=" * 55)
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"zip error: {exc}"
+
+
+@command("zinb", usage="zinb depvar indepvars")
+def cmd_zinb(session: Session, args: str) -> str:
+    """Zero-Inflated Negative Binomial regression."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_eq(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: zinb depvar indepvar1 ..."
+    try:
+        from openstat.stats.advanced_regression import fit_zinb
+        result = fit_zinb(df, dep, indeps)
+        session._last_model = result
+        lines = [f"\n{result['method']}: {dep}", "=" * 55]
+        lines.append(f"  N = {result['n_obs']}   AIC = {result['aic']:.4f}   LL = {result['log_likelihood']:.4f}")
+        lines.append("\nCoefficients:")
+        lines.append(_coef_table(result["params"], result["std_errors"], result["p_values"]))
+        lines.append("=" * 55)
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"zinb error: {exc}"
+
+
+@command("hurdle", usage="hurdle depvar indepvars")
+def cmd_hurdle(session: Session, args: str) -> str:
+    """Hurdle model: Logit for zeros + Poisson for positives."""
+    df = session.require_data()
+    dep, indeps, opts = _parse_eq(args, df.columns)
+    if not dep or not indeps:
+        return "Usage: hurdle depvar indepvar1 ..."
+    try:
+        from openstat.stats.advanced_regression import fit_hurdle
+        result = fit_hurdle(df, dep, indeps)
+        session._last_model = result
+        lines = [f"\nHurdle Model: {dep}", "=" * 55]
+        lines.append(f"  N = {result['n_obs']}   Zeros = {result['n_zeros']}   Positive = {result['n_positive']}")
+        lines.append("\nPart 1 — Logit (P(y > 0)):")
+        lines.append(_coef_table(result["logit_params"], pvals=result["logit_pvalues"]))
+        lines.append("\nPart 2 — Poisson (E[y | y > 0]):")
+        lines.append(_coef_table(result["count_params"], pvals=result["count_pvalues"]))
+        lines.append("=" * 55)
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"hurdle error: {exc}"
+
+
+@command("sureg", usage="sureg (dep1 x1 x2) (dep2 x3 x4)")
+def cmd_sureg(session: Session, args: str) -> str:
+    """Seemingly Unrelated Regression."""
+    df = session.require_data()
+    # Parse parenthesized equations: (dep x1 x2) (dep2 x3 x4)
+    eq_matches = re.findall(r'\(([^)]+)\)', args)
+    if not eq_matches:
+        return "Usage: sureg (dep1 x1 x2) (dep2 x3 x4)"
+
+    equations = []
+    for eq_str in eq_matches:
+        parts = eq_str.split()
+        if len(parts) < 2:
+            continue
+        dep = parts[0]
+        indeps = [c for c in parts[1:] if c in df.columns]
+        if dep in df.columns and indeps:
+            equations.append((dep, indeps))
+
+    if not equations:
+        return "No valid equations found."
+    try:
+        from openstat.stats.advanced_regression import fit_sur
+        result = fit_sur(df, equations)
+        session._last_model = result
+        lines = [f"\nSUR: {result['n_equations']} equations", "=" * 60]
+        for eq in result["equations"]:
+            lines.append(f"\nEquation {eq['equation']}: {eq['dep']}   R² = {eq['r_squared']:.4f}   N = {eq['n_obs']}")
+            lines.append(_coef_table(eq["params"], eq["std_errors"]))
+        lines.append("=" * 60)
+        return "\n".join(lines)
+    except Exception as exc:
+        return f"sureg error: {exc}"

openstat/commands/alias_cmds.py

@@ -0,0 +1,135 @@
+"""Alias and theme commands."""
+
+from __future__ import annotations
+
+from openstat.commands.base import command, CommandArgs, get_registry, friendly_error
+from openstat.session import Session
+
+# Module-level alias store
+_ALIASES: dict[str, str] = {}
+
+
+def get_aliases() -> dict[str, str]:
+    return _ALIASES
+
+
+def resolve_alias(line: str) -> str:
+    """If line starts with a known alias, expand it."""
+    token = line.split()[0] if line.split() else ""
+    if token in _ALIASES:
+        rest = line[len(token):].strip()
+        expanded = _ALIASES[token]
+        return f"{expanded} {rest}".strip() if rest else expanded
+    return line
+
+
+@command("alias", usage="alias [<name> <expansion>] | alias list | alias rm <name>")
+def cmd_alias(session: Session, args: str) -> str:
+    """Define or manage command aliases.
+
+    Examples:
+      alias reg ols          — 'reg y x' → 'ols y x'
+      alias desc describe
+      alias list             — show all aliases
+      alias rm reg           — remove alias
+    """
+    tokens = args.strip().split(None, 2)
+
+    if not tokens or tokens[0] == "list":
+        if not _ALIASES:
+            return "No aliases defined. Use: alias <name> <expansion>"
+        lines = ["Aliases:", "  {:<15} {}".format("Name", "Expansion"), "-" * 40]
+        for k, v in sorted(_ALIASES.items()):
+            lines.append(f"  {k:<15} {v}")
+        return "\n".join(lines)
+
+    if tokens[0] == "rm":
+        if len(tokens) < 2:
+            return "Usage: alias rm <name>"
+        name = tokens[1]
+        if name in _ALIASES:
+            del _ALIASES[name]
+            return f"Alias '{name}' removed."
+        return f"Alias '{name}' not found."
+
+    if len(tokens) < 2:
+        return "Usage: alias <name> <expansion>"
+
+    name = tokens[0]
+    expansion = " ".join(tokens[1:])
+
+    # Prevent aliasing built-in if it would shadow itself
+    if name == expansion.split()[0]:
+        return f"Cannot alias '{name}' to itself."
+
+    _ALIASES[name] = expansion
+    return f"Alias set: {name} → {expansion}"
+
+
+# ── theme ─────────────────────────────────────────────────────────────────────
+
+_THEMES: dict[str, dict[str, str]] = {
+    "dark": {
+        "prompt": "bold cyan",
+        "output": "white",
+        "error": "bold red",
+        "info": "bright_blue",
+    },
+    "light": {
+        "prompt": "bold blue",
+        "output": "black",
+        "error": "bold red",
+        "info": "blue",
+    },
+    "solarized": {
+        "prompt": "bold yellow",
+        "output": "bright_white",
+        "error": "bold magenta",
+        "info": "cyan",
+    },
+    "matrix": {
+        "prompt": "bold green",
+        "output": "green",
+        "error": "bold red",
+        "info": "bright_green",
+    },
+}
+
+_ACTIVE_THEME: str = "dark"
+
+
+def get_active_theme() -> dict[str, str]:
+    return _THEMES.get(_ACTIVE_THEME, _THEMES["dark"])
+
+
+@command("theme", usage="theme [<name>] | theme list")
+def cmd_theme(session: Session, args: str) -> str:
+    """Set or list color themes.
+
+    Available themes: dark (default), light, solarized, matrix.
+
+    Examples:
+      theme            — show current theme
+      theme list       — list all themes
+      theme solarized  — switch to solarized
+    """
+    tokens = args.strip().split()
+
+    if not tokens:
+        return f"Current theme: {_ACTIVE_THEME}"
+
+    if tokens[0] == "list":
+        lines = ["Available themes:"]
+        for name in _THEMES:
+            marker = " (active)" if name == _ACTIVE_THEME else ""
+            lines.append(f"  {name}{marker}")
+        return "\n".join(lines)
+
+    name = tokens[0].lower()
+    if name not in _THEMES:
+        available = ", ".join(_THEMES)
+        return f"Unknown theme: {name}. Available: {available}"
+
+    import openstat.commands.alias_cmds as _self
+    _self._ACTIVE_THEME = name
+    return f"Theme set to: {name}"

openstat/commands/arch_cmds.py

@@ -0,0 +1,82 @@
+"""ARCH/GARCH volatility model commands."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.commands.base import command
+from openstat.session import Session
+
+
+def _stata_opts(raw: str) -> tuple[list[str], dict[str, str]]:
+    opts: dict[str, str] = {}
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+    positional = [t.strip(',') for t in rest.split() if t.strip(',')]
+    return positional, opts
+
+
+def _arch_table(result: dict) -> str:
+    lines = [f"\n{result['model']}: {result['var']}", "=" * 55]
+    lines.append(f"  {'N observations':<25}  {result['n_obs']}")
+    lines.append(f"  {'Log-likelihood':<25}  {result['log_likelihood']:.4f}")
+    lines.append(f"  {'AIC':<25}  {result['aic']:.4f}")
+    lines.append(f"  {'BIC':<25}  {result['bic']:.4f}")
+    lines.append("\nParameters:")
+    for name, val in result["params"].items():
+        lines.append(f"  {name:<25}  {val:>12.6f}")
+    if "cond_volatility_last5" in result:
+        lines.append("\nConditional volatility (last 5 obs):")
+        for v in result["cond_volatility_last5"]:
+            lines.append(f"  {v:.4f}")
+    lines.append("=" * 55)
+    return "\n".join(lines)
+
+
+@command("arch", usage="arch var [, p(1) dist(normal|t)]")
+def cmd_arch(session: Session, args: str) -> str:
+    """ARCH(p) model for volatility clustering."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if not positional:
+        return "Usage: arch var [, p(1) dist(normal)]"
+
+    var = positional[0]
+    p = int(opts.get("p", 1))
+    dist = opts.get("dist", "normal")
+
+    try:
+        from openstat.stats.arch_garch import fit_arch
+        result = fit_arch(df, var, p=p, dist=dist)
+        session._last_model = result
+        return _arch_table(result)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"arch error: {exc}"
+
+
+@command("garch", usage="garch var [, p(1) q(1) model(GARCH|EGARCH|GJR-GARCH) dist(normal)]")
+def cmd_garch(session: Session, args: str) -> str:
+    """GARCH(p,q) or variant volatility model."""
+    df = session.require_data()
+    positional, opts = _stata_opts(args)
+    if not positional:
+        return "Usage: garch var [, p(1) q(1) model(GARCH) dist(normal)]"
+
+    var = positional[0]
+    p = int(opts.get("p", 1))
+    q = int(opts.get("q", 1))
+    dist = opts.get("dist", "normal")
+    model = opts.get("model", "GARCH")
+
+    try:
+        from openstat.stats.arch_garch import fit_garch
+        result = fit_garch(df, var, p=p, q=q, dist=dist, model=model)
+        session._last_model = result
+        return _arch_table(result)
+    except ImportError as e:
+        return str(e)
+    except Exception as exc:
+        return f"garch error: {exc}"

openstat/commands/arules_cmds.py

@@ -0,0 +1,111 @@
+"""Association rules: Apriori / FP-Growth."""
+
+from __future__ import annotations
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+@command("arules", usage="arules <item_col> [<id_col>] [--minsup=0.05] [--minconf=0.5] [--algo=fpgrowth]")
+def cmd_arules(session: Session, args: str) -> str:
+    """Association rule mining (Apriori / FP-Growth).
+
+    Mines frequent itemsets and generates association rules.
+    Expects one-row-per-transaction with an item column, OR
+    a transaction-id column + item column.
+
+    Options:
+      --minsup=<f>    minimum support (0–1, default: 0.05)
+      --minconf=<f>   minimum confidence (0–1, default: 0.5)
+      --minlift=<f>   minimum lift (default: 1.0)
+      --algo=<a>      apriori or fpgrowth (default: fpgrowth)
+      --top=<n>       show top N rules (default: 20)
+
+    Examples:
+      arules item transaction_id --minsup=0.1 --minconf=0.6
+      arules product --minsup=0.05 --algo=apriori --top=10
+    """
+    try:
+        from mlxtend.frequent_patterns import fpgrowth, apriori, association_rules
+        from mlxtend.preprocessing import TransactionEncoder
+    except ImportError:
+        return "mlxtend required. Install: pip install mlxtend"
+
+    import polars as pl
+    import pandas as pd
+
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: arules <item_col> [<id_col>]"
+
+    item_col = ca.positional[0]
+    id_col = ca.positional[1] if len(ca.positional) > 1 else None
+    min_sup = float(ca.options.get("minsup", 0.05))
+    min_conf = float(ca.options.get("minconf", 0.5))
+    min_lift = float(ca.options.get("minlift", 1.0))
+    algo = ca.options.get("algo", "fpgrowth").lower()
+    top_n = int(ca.options.get("top", 20))
+
+    try:
+        df = session.require_data()
+        if item_col not in df.columns:
+            return f"Column not found: {item_col}"
+        if id_col and id_col not in df.columns:
+            return f"Column not found: {id_col}"
+
+        # Build transactions
+        if id_col:
+            # Group items by transaction id
+            transactions = (
+                df.select([id_col, item_col])
+                .group_by(id_col)
+                .agg(pl.col(item_col).cast(pl.Utf8).alias("items"))
+                ["items"].to_list()
+            )
+        else:
+            # Each row is a transaction; split by comma if needed
+            col_vals = df[item_col].cast(pl.Utf8).to_list()
+            transactions = [[v.strip() for v in row.split(",") if v.strip()]
+                            for row in col_vals if row]
+
+        if len(transactions) < 2:
+            return "Need at least 2 transactions."
+
+        te = TransactionEncoder()
+        te_array = te.fit(transactions).transform(transactions)
+        basket_df = pd.DataFrame(te_array, columns=te.columns_)
+
+        if algo == "apriori":
+            frequent = apriori(basket_df, min_support=min_sup, use_colnames=True)
+        else:
+            frequent = fpgrowth(basket_df, min_support=min_sup, use_colnames=True)
+
+        if frequent.empty:
+            return f"No frequent itemsets found at min_support={min_sup}. Try lowering --minsup."
+
+        rules = association_rules(frequent, metric="confidence", min_threshold=min_conf)
+        rules = rules[rules["lift"] >= min_lift].sort_values("lift", ascending=False)
+
+        lines = [
+            f"Association Rules ({algo.upper()}) — {item_col}",
+            f"  Transactions: {len(transactions)}, Items: {len(te.columns_)}",
+            f"  min_support={min_sup}, min_confidence={min_conf}, min_lift={min_lift}",
+            f"  Frequent itemsets: {len(frequent)}, Rules: {len(rules)}",
+            "",
+        ]
+
+        if rules.empty:
+            lines.append("  No rules found. Try lowering --minconf or --minlift.")
+        else:
+            lines.append(f"  Top {min(top_n, len(rules))} rules by lift:")
+            lines.append(f"  {'Antecedent':<30} {'Consequent':<20} {'Sup':>7} {'Conf':>7} {'Lift':>7}")
+            lines.append("  " + "-" * 75)
+            for _, row in rules.head(top_n).iterrows():
+                ant = ", ".join(sorted(row["antecedents"]))[:28]
+                con = ", ".join(sorted(row["consequents"]))[:18]
+                lines.append(
+                    f"  {ant:<30} {con:<20} {row['support']:>7.3f} {row['confidence']:>7.3f} {row['lift']:>7.3f}"
+                )
+
+        return "\n".join(lines)
+    except Exception as e:
+        return friendly_error(e, "arules")