openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/outreg_cmds.py

@@ -0,0 +1,247 @@
+"""outreg: export regression results to LaTeX or HTML tables. log: session logging."""
+
+from __future__ import annotations
+
+import re
+from datetime import datetime
+
+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 _results_to_table(results, fmt: str = "latex", stars: bool = True) -> str:
+    """Convert session results to LaTeX or HTML table."""
+    # Normalize ModelResult → dict
+    model_list = []
+    for res in results:
+        if isinstance(res, dict) and ("params" in res or "coefficients" in res):
+            model_list.append(res)
+        elif hasattr(res, "details"):
+            d = res.details
+            if "params" in d or "coefficients" in d:
+                model_list.append(d)
+
+    if not model_list:
+        return ""
+
+    all_params: list[str] = []
+    for res in model_list:
+        src = res.get("params") or res.get("coefficients") or {}
+        for p in src:
+            if p not in all_params:
+                all_params.append(p)
+
+    def _coef(res, param):
+        if "params" in res:
+            return res["params"].get(param, float("nan"))
+        c = res.get("coefficients", {}).get(param, {})
+        return c.get("mean", float("nan"))
+
+    def _se(res, param):
+        if "std_errors" in res:
+            return res["std_errors"].get(param, float("nan"))
+        c = res.get("coefficients", {}).get(param, {})
+        return c.get("std", float("nan"))
+
+    def _pval(res, param):
+        if "p_values" in res:
+            return res["p_values"].get(param, float("nan"))
+        return float("nan")
+
+    def _star(p):
+        if p != p: return ""
+        if p < 0.001: return "^{***}" if fmt == "latex" else "***"
+        if p < 0.01: return "^{**}" if fmt == "latex" else "**"
+        if p < 0.05: return "^{*}" if fmt == "latex" else "*"
+        return ""
+
+    n_models = len(model_list)
+
+    if fmt == "latex":
+        col_spec = "l" + "c" * n_models
+        lines = [
+            "\\begin{table}[htbp]",
+            "\\centering",
+            f"\\begin{{tabular}}{{{col_spec}}}",
+            "\\hline\\hline",
+        ]
+        header = " & " + " & ".join(f"({i+1})" for i in range(n_models)) + " \\\\"
+        lines.append(header)
+        lines.append("\\hline")
+        for param in all_params:
+            coef_row = param.replace("_", "\\_") + " & "
+            se_row = " & "
+            vals = []
+            ses = []
+            for res in model_list:
+                c = _coef(res, param)
+                s = _se(res, param)
+                p = _pval(res, param)
+                st = _star(p) if stars else ""
+                vals.append(f"{c:.4f}{st}" if c == c else "")
+                ses.append(f"({s:.4f})" if s == s else "")
+            coef_row += " & ".join(vals) + " \\\\"
+            se_row += " & ".join(ses) + " \\\\"
+            lines.append(coef_row)
+            lines.append(se_row)
+        lines.append("\\hline")
+        n_row = "N & " + " & ".join(str(res.get("n_obs", "")) for res in model_list) + " \\\\"
+        r2_row = "$R^2$ & " + " & ".join(
+            f"{res.get('r_squared', float('nan')):.4f}" if isinstance(res.get('r_squared'), float) else ""
+            for res in model_list
+        ) + " \\\\"
+        lines.extend([n_row, r2_row, "\\hline\\hline"])
+        if stars:
+            lines.append("\\multicolumn{" + str(n_models + 1) + "}{l}{\\footnotesize $^{*}p<0.05$, $^{**}p<0.01$, $^{***}p<0.001$}")
+        lines.extend(["\\end{tabular}", "\\end{table}"])
+        return "\n".join(lines)
+
+    else:  # html
+        lines = ["<table border='1' cellpadding='5' style='border-collapse:collapse'>"]
+        lines.append("<tr><th>Variable</th>" + "".join(f"<th>({i+1})</th>" for i in range(n_models)) + "</tr>")
+        for param in all_params:
+            coef_cells = ""
+            se_cells = ""
+            for res in model_list:
+                c = _coef(res, param)
+                s = _se(res, param)
+                p = _pval(res, param)
+                st = _star(p) if stars else ""
+                coef_cells += f"<td align='center'>{f'{c:.4f}{st}' if c==c else ''}</td>"
+                se_cells += f"<td align='center'><small>{f'({s:.4f})' if s==s else ''}</small></td>"
+            lines.append(f"<tr><td><b>{param}</b></td>{coef_cells}</tr>")
+            lines.append(f"<tr><td></td>{se_cells}</tr>")
+        n_row = "<tr><td>N</td>" + "".join(f"<td align='center'>{res.get('n_obs','')}</td>" for res in model_list) + "</tr>"
+        def _r2_cell(res):
+            r2 = res.get("r_squared", None)
+            val = f"{r2:.4f}" if isinstance(r2, float) else ""
+            return f"<td align='center'>{val}</td>"
+        r2_row = "<tr><td>R\u00b2</td>" + "".join(_r2_cell(res) for res in model_list) + "</tr>"
+        lines.extend([n_row, r2_row, "</table>"])
+        if stars: lines.append("<p><small>* p&lt;0.05, ** p&lt;0.01, *** p&lt;0.001</small></p>")
+        return "\n".join(lines)
+
+
+@command("outreg", usage="outreg [using path] [format(latex|html)] [--stars]")
+def cmd_outreg(session: Session, args: str) -> str:
+    """Export regression comparison table to LaTeX or HTML."""
+    positional, opts = _stata_opts(args)
+    fmt = opts.get("format", "latex")
+    show_stars = "stars" in args or "--stars" in args
+    path = opts.get("using")
+    # Also accept: outreg using file.tex
+    if not path and "using" in positional:
+        idx = positional.index("using")
+        if idx + 1 < len(positional):
+            path = positional[idx + 1]
+
+    if not session.results:
+        return "No stored results. Run regression commands first."
+
+    table = _results_to_table(session.results, fmt=fmt, stars=show_stars)
+    if not table:
+        return "No regression results with coefficients found."
+
+    if path:
+        try:
+            import os
+            os.makedirs(os.path.dirname(path) if os.path.dirname(path) else ".", exist_ok=True)
+            with open(path, "w") as f:
+                f.write(table)
+            return f"outreg: table saved to {path} ({fmt} format)"
+        except Exception as exc:
+            return f"outreg write error: {exc}"
+
+    return f"\noutreg ({fmt}):\n\n{table}"
+
+
+@command("log", usage="log using <path> | log close | log status | log display | log clear")
+def cmd_log(session: Session, args: str) -> str:
+    """Session logging: real-time capture or history export.
+
+    Examples:
+      log using analysis.log   — start real-time logging
+      log status               — check if logging is active
+      log close                — stop real-time log and close file
+      log display              — print command history to screen
+      log clear                — clear command history
+    """
+    import os
+    from pathlib import Path
+
+    stripped = args.strip()
+    positional, opts = _stata_opts(args)
+    subcmd = positional[0].lower() if positional else "display"
+
+    # ---- Real-time logging ----
+    if subcmd == "using":
+        log_path = positional[1] if len(positional) >= 2 else opts.get("using", "outputs/session.log")
+        # Close existing real-time log if open
+        if session._log_file is not None:
+            try:
+                session._log_file.write(f"\nLog replaced {datetime.now().isoformat()}\n")
+                session._log_file.close()
+            except Exception:
+                pass
+        path = Path(log_path)
+        path.parent.mkdir(parents=True, exist_ok=True)
+        try:
+            session._log_file = open(path, "w", encoding="utf-8")
+            session._log_path = str(path)
+            session._log_file.write("OpenStat session log\n")
+            session._log_file.write(f"Started: {datetime.now().isoformat()}\n")
+            session._log_file.write("=" * 60 + "\n\n")
+            session._log_file.flush()
+            return f"Log opened: {path}"
+        except OSError as exc:
+            return f"log error: {exc}"
+
+    elif subcmd in ("close", "off"):
+        if session._log_file is None:
+            return "No active log. Use: log using <path>"
+        closed_path = session._log_path
+        try:
+            session._log_file.write(f"\nLog closed {datetime.now().isoformat()}\n")
+            session._log_file.close()
+        except Exception:
+            pass
+        session._log_file = None
+        session._log_path = None
+        return f"Log closed: {closed_path}"
+
+    elif subcmd == "status":
+        if session._log_file is None:
+            return "Logging: OFF"
+        return f"Logging: ON  →  {session._log_path}"
+
+    # ---- History display / export ----
+    elif subcmd == "display":
+        if not session.history:
+            return "No commands in session history."
+        lines = ["\nSession Log:", "=" * 50]
+        for i, cmd_line in enumerate(session.history, 1):
+            lines.append(f"  {i:>4}. {cmd_line}")
+        return "\n".join(lines)
+
+    elif subcmd == "clear":
+        session.history.clear()
+        return "Session history cleared."
+
+    else:
+        return (
+            "Usage:\n"
+            "  log using <path>   — start real-time logging to file\n"
+            "  log status         — check if logging is active\n"
+            "  log close          — stop logging\n"
+            "  log display        — show command history\n"
+            "  log clear          — clear command history"
+        )

openstat/commands/panel_cmds.py

@@ -0,0 +1,141 @@
+"""Panel data commands: xtset, xtreg, hausman."""
+
+from __future__ import annotations
+
+import re
+
+from openstat.session import Session, ModelResult
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.dsl.parser import parse_formula, ParseError
+
+
+def _store_panel_model(session, result, raw_model, dep, indeps, fit_kwargs=None):
+    """Store panel model result in session."""
+    session._last_model = raw_model
+    session._last_model_vars = (dep, indeps)
+    session._last_fit_result = result
+    session._last_fit_kwargs = fit_kwargs or {}
+    md = result.to_markdown() if hasattr(result, "to_markdown") else str(result)
+    details = {
+        "n_obs": result.n_obs,
+        "params": dict(result.params),
+        "std_errors": dict(result.std_errors),
+    }
+    if result.r_squared is not None:
+        details["r_squared"] = result.r_squared
+    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("xtset", usage="xtset <panel_var> <time_var>")
+def cmd_xtset(session: Session, args: str) -> str:
+    """Declare panel structure: entity and time variables."""
+    df = session.require_data()
+    parts = args.strip().split()
+    if len(parts) < 2:
+        return "Usage: xtset <panel_var> <time_var>"
+
+    panel_var, time_var = parts[0], parts[1]
+    for v in (panel_var, time_var):
+        if v not in df.columns:
+            return f"Column not found: {v}"
+
+    n_entities = df[panel_var].n_unique()
+    n_periods = df[time_var].n_unique()
+    session._panel_var = panel_var
+    session._time_var = time_var
+
+    return (
+        f"Panel variable: {panel_var} ({n_entities} entities)\n"
+        f"Time variable: {time_var} ({n_periods} periods)\n"
+        f"Observations: {df.height}"
+    )
+
+
+@command("xtreg", usage="xtreg y ~ x1 + x2, fe|re|be [--robust] [--cluster]")
+def cmd_xtreg(session: Session, args: str) -> str:
+    """Fit panel data regression: fixed effects, random effects, or between."""
+    df = session.require_data()
+
+    if session._panel_var is None or session._time_var is None:
+        return "Panel structure not set. Use: xtset <panel_var> <time_var>"
+
+    # Split on comma to get formula and estimator
+    if "," in args:
+        formula_part, options_part = args.rsplit(",", 1)
+    else:
+        return "Usage: xtreg y ~ x1 + x2, fe|re|be [--robust]"
+
+    ca = CommandArgs(options_part)
+    estimator = None
+    for est in ("fe", "re", "be"):
+        if est in [p.lower() for p in ca.positional]:
+            estimator = est
+            break
+    if estimator is None:
+        return "Specify estimator: fe (fixed effects), re (random effects), or be (between)"
+
+    robust = ca.has_flag("--robust") or "--robust" in formula_part
+    cluster = ca.get_option("cluster")
+    formula_clean = formula_part.replace("--robust", "").strip()
+    # Remove cluster option from formula
+    formula_clean = re.sub(r'--cluster=\S+', '', formula_clean).strip()
+
+    try:
+        dep, indeps = parse_formula(formula_clean)
+    except ParseError as e:
+        return f"Formula error: {e}"
+
+    try:
+        from openstat.stats.panel import fit_panel_fe, fit_panel_re, fit_panel_be
+
+        if estimator == "fe":
+            result, raw = fit_panel_fe(
+                df, dep, indeps, session._panel_var, session._time_var,
+                robust=robust, cluster=cluster,
+            )
+        elif estimator == "re":
+            result, raw = fit_panel_re(
+                df, dep, indeps, session._panel_var, session._time_var,
+                robust=robust,
+            )
+        else:  # be
+            result, raw = fit_panel_be(
+                df, dep, indeps, session._panel_var, session._time_var,
+            )
+
+        # Store raw model for hausman test
+        session._panel_models[estimator] = raw
+
+        return _store_panel_model(
+            session, result, raw, dep, indeps,
+            {"estimator": estimator, "robust": robust},
+        )
+    except ImportError as e:
+        return str(e)
+    except Exception as e:
+        return friendly_error(e, "xtreg")
+
+
+@command("hausman", usage="hausman")
+def cmd_hausman(session: Session, args: str) -> str:
+    """Hausman test: compare FE vs RE. Run both xtreg fe and xtreg re first."""
+    fe_raw = session._panel_models.get("fe")
+    re_raw = session._panel_models.get("re")
+
+    if not fe_raw or not re_raw:
+        return "Run both 'xtreg ..., fe' and 'xtreg ..., re' first."
+
+    try:
+        from openstat.stats.panel import hausman_test
+        return hausman_test(fe_raw, re_raw)
+    except ImportError as e:
+        return str(e)
+    except Exception as e:
+        return friendly_error(e, "hausman")

openstat/commands/pdf_cmds.py

@@ -0,0 +1,226 @@
+"""PDF and Markdown export commands."""
+
+from __future__ import annotations
+
+import os
+from datetime import date
+from pathlib import Path
+
+from openstat.commands.base import command, CommandArgs
+from openstat.session import Session
+
+
+def _ensure_dir(path: str) -> None:
+    os.makedirs(os.path.dirname(os.path.abspath(path)), exist_ok=True)
+
+
+# ── Markdown export ──────────────────────────────────────────────────────────
+
+def _export_md(session: Session, path: str) -> str:
+    import polars as pl
+
+    lines = [
+        f"# OpenStat Results",
+        f"",
+        f"**Dataset:** {session.dataset_name or 'Unknown'}  |  "
+        f"**Date:** {date.today().isoformat()}  |  "
+        f"**Shape:** {session.shape_str}",
+        f"",
+    ]
+
+    if session.df is not None:
+        df = session.df
+        lines += ["## Dataset Overview", ""]
+        lines += [
+            f"| Property | Value |",
+            f"|---|---|",
+            f"| Rows | {df.height:,} |",
+            f"| Columns | {df.width} |",
+            f"| Missing cells | {sum(df[c].null_count() for c in df.columns)} |",
+        ]
+        lines.append("")
+
+        NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+                   pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+        num_cols = [c for c in df.columns if df[c].dtype in NUMERIC]
+        if num_cols:
+            lines += ["## Summary Statistics", ""]
+            lines.append("| Variable | N | Mean | SD | Min | Max |")
+            lines.append("|---|---|---|---|---|---|")
+            for c in num_cols[:30]:
+                col = df[c].drop_nulls()
+                if col.len() == 0:
+                    continue
+                mean = f"{col.mean():.4f}"
+                sd = f"{col.std():.4f}" if col.len() > 1 else "—"
+                lines.append(
+                    f"| {c} | {col.len()} | {mean} | {sd} "
+                    f"| {col.min():.4f} | {col.max():.4f} |"
+                )
+            lines.append("")
+
+    for mr in session.results:
+        lines += [
+            f"## {mr.name}: {mr.formula}",
+            "",
+            "```",
+            mr.table,
+            "```",
+            "",
+        ]
+
+    if session.plot_paths:
+        lines += ["## Figures", ""]
+        for p in session.plot_paths:
+            if os.path.exists(p):
+                lines.append(f"![Figure]({p})")
+        lines.append("")
+
+    content = "\n".join(lines)
+    _ensure_dir(path)
+    Path(path).write_text(content, encoding="utf-8")
+    return os.path.abspath(path)
+
+
+# ── PDF export ───────────────────────────────────────────────────────────────
+
+def _export_pdf(session: Session, path: str) -> str:
+    try:
+        from reportlab.lib.pagesizes import A4
+        from reportlab.lib.styles import getSampleStyleSheet, ParagraphStyle
+        from reportlab.lib.units import cm
+        from reportlab.lib import colors
+        from reportlab.platypus import (
+            SimpleDocTemplate, Paragraph, Spacer, Table, TableStyle, Image,
+            HRFlowable,
+        )
+        from reportlab.lib.enums import TA_LEFT
+    except ImportError:
+        return (
+            "reportlab is required for PDF export.\n"
+            "Install: pip install reportlab"
+        )
+
+    import polars as pl
+
+    doc = SimpleDocTemplate(
+        path,
+        pagesize=A4,
+        leftMargin=2 * cm, rightMargin=2 * cm,
+        topMargin=2 * cm, bottomMargin=2 * cm,
+    )
+    styles = getSampleStyleSheet()
+    mono = ParagraphStyle("Mono", parent=styles["Normal"], fontName="Courier", fontSize=8, leading=11)
+    h1 = styles["Heading1"]
+    h2 = styles["Heading2"]
+    normal = styles["Normal"]
+
+    story = []
+
+    # Title
+    story.append(Paragraph("OpenStat Results", h1))
+    story.append(Paragraph(
+        f"Dataset: {session.dataset_name or 'Unknown'}  |  "
+        f"Date: {date.today().isoformat()}  |  "
+        f"Shape: {session.shape_str}",
+        normal,
+    ))
+    story.append(HRFlowable(width="100%"))
+    story.append(Spacer(1, 0.3 * cm))
+
+    # Dataset overview table
+    if session.df is not None:
+        df = session.df
+        story.append(Paragraph("Dataset Overview", h2))
+        NUMERIC = (pl.Float32, pl.Float64, pl.Int8, pl.Int16, pl.Int32, pl.Int64,
+                   pl.UInt8, pl.UInt16, pl.UInt32, pl.UInt64)
+        overview_data = [
+            ["Property", "Value"],
+            ["Rows", f"{df.height:,}"],
+            ["Columns", str(df.width)],
+            ["Missing cells", str(sum(df[c].null_count() for c in df.columns))],
+            ["Numeric columns", str(sum(1 for c in df.columns if df[c].dtype in NUMERIC))],
+        ]
+        tbl = Table(overview_data, colWidths=[6 * cm, 10 * cm])
+        tbl.setStyle(TableStyle([
+            ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#4C72B0")),
+            ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+            ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+            ("GRID", (0, 0), (-1, -1), 0.5, colors.grey),
+            ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f0f4ff")]),
+            ("FONTSIZE", (0, 0), (-1, -1), 9),
+        ]))
+        story.append(tbl)
+        story.append(Spacer(1, 0.5 * cm))
+
+        # Summary statistics
+        num_cols = [c for c in df.columns if df[c].dtype in NUMERIC]
+        if num_cols:
+            story.append(Paragraph("Summary Statistics", h2))
+            stats_data = [["Variable", "N", "Mean", "SD", "Min", "Max"]]
+            for c in num_cols[:25]:
+                col = df[c].drop_nulls()
+                if col.len() == 0:
+                    continue
+                sd_str = f"{col.std():.4f}" if col.len() > 1 else "—"
+                stats_data.append([
+                    c, str(col.len()),
+                    f"{col.mean():.4f}", sd_str,
+                    f"{col.min():.4f}", f"{col.max():.4f}",
+                ])
+            st = Table(stats_data, colWidths=[4*cm, 1.5*cm, 2.5*cm, 2.5*cm, 2.5*cm, 2.5*cm])
+            st.setStyle(TableStyle([
+                ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#4C72B0")),
+                ("TEXTCOLOR", (0, 0), (-1, 0), colors.white),
+                ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
+                ("GRID", (0, 0), (-1, -1), 0.5, colors.grey),
+                ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#f0f4ff")]),
+                ("FONTSIZE", (0, 0), (-1, -1), 8),
+            ]))
+            story.append(st)
+            story.append(Spacer(1, 0.5 * cm))
+
+    # Model results
+    for mr in session.results:
+        story.append(Paragraph(f"{mr.name}: {mr.formula}", h2))
+        # Wrap long table text in monospace paragraphs
+        for line in mr.table.split("\n"):
+            story.append(Paragraph(line.replace(" ", " ") or " ", mono))
+        story.append(Spacer(1, 0.4 * cm))
+
+    # Plots
+    for plot_path in session.plot_paths:
+        if os.path.exists(plot_path):
+            story.append(Paragraph("Figure", h2))
+            try:
+                img = Image(plot_path, width=15 * cm, height=10 * cm, kind="proportional")
+                story.append(img)
+            except Exception:
+                story.append(Paragraph(f"[Plot: {plot_path}]", normal))
+            story.append(Spacer(1, 0.3 * cm))
+
+    _ensure_dir(path)
+    doc.build(story)
+    return os.path.abspath(path)
+
+
+# ── Commands ─────────────────────────────────────────────────────────────────
+
+@command("export pdf", usage="export pdf [path]")
+def cmd_export_pdf(session: Session, args: str) -> str:
+    """Export results to a PDF report (requires reportlab)."""
+    ca = CommandArgs(args)
+    path = ca.positional[0] if ca.positional else "outputs/results.pdf"
+    out = _export_pdf(session, path)
+    if out.endswith(".pdf"):
+        return f"PDF saved: {out}"
+    return out
+
+
+@command("export md", usage="export md [path]")
+def cmd_export_md(session: Session, args: str) -> str:
+    """Export results to a Markdown file."""
+    ca = CommandArgs(args)
+    path = ca.positional[0] if ca.positional else "outputs/results.md"
+    out = _export_md(session, path)
+    return f"Markdown saved: {out}"