openstat-cli 1.0.0__py3-none-any.whl

openstat/commands/export_cmds.py

@@ -0,0 +1,201 @@
+"""Export commands: export docx, export pptx."""
+
+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)
+
+
+# ── Word (.docx) ───────────────────────────────────────────────────────────
+
+def _export_docx(session: Session, path: str) -> str:
+    try:
+        from docx import Document
+        from docx.shared import Pt, RGBColor
+    except ImportError:
+        return (
+            "python-docx is required for Word export.\n"
+            "Install: pip install python-docx"
+        )
+
+    doc = Document()
+    doc.add_heading("OpenStat Results", 0)
+    doc.add_paragraph(
+        f"Dataset: {session.dataset_name or 'Unknown'}  |  "
+        f"Date: {date.today().isoformat()}  |  "
+        f"Shape: {session.shape_str}"
+    )
+    doc.add_paragraph()
+
+    # Dataset overview table
+    doc.add_heading("Dataset Overview", level=1)
+    if session.df is not None:
+        df = session.df
+        tbl = doc.add_table(rows=1, cols=2)
+        tbl.style = "Table Grid"
+        hdr = tbl.rows[0].cells
+        hdr[0].text = "Property"
+        hdr[1].text = "Value"
+        for label, val in [
+            ("Rows", str(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 (
+                __import__("polars").Float32, __import__("polars").Float64,
+                __import__("polars").Int32, __import__("polars").Int64,
+            )))),
+        ]:
+            row = tbl.add_row().cells
+            row[0].text = label
+            row[1].text = val
+        doc.add_paragraph()
+
+        # Summary statistics table
+        import polars as pl
+        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:
+            doc.add_heading("Summary Statistics", level=2)
+            stats_tbl = doc.add_table(rows=1, cols=5)
+            stats_tbl.style = "Table Grid"
+            for i, hdr_text in enumerate(["Variable", "N", "Mean", "SD", "Min–Max"]):
+                stats_tbl.rows[0].cells[i].text = hdr_text
+            for c in num_cols[:20]:  # cap at 20 rows
+                col = df[c].drop_nulls()
+                if col.len() == 0:
+                    continue
+                cells = stats_tbl.add_row().cells
+                cells[0].text = c
+                cells[1].text = str(col.len())
+                cells[2].text = f"{col.mean():.4f}"
+                cells[3].text = f"{col.std():.4f}" if col.len() > 1 else "—"
+                cells[4].text = f"{col.min():.2f} – {col.max():.2f}"
+
+    # Model results
+    for mr in session.results:
+        doc.add_heading(f"{mr.name}: {mr.formula}", level=1)
+        doc.add_paragraph(mr.table, style="No Spacing")
+        doc.add_paragraph()
+
+    # Plots
+    for plot_path in session.plot_paths:
+        if os.path.exists(plot_path):
+            doc.add_heading("Figure", level=2)
+            try:
+                doc.add_picture(plot_path)
+            except Exception:
+                doc.add_paragraph(f"[Plot: {plot_path}]")
+
+    _ensure_dir(path)
+    doc.save(path)
+    return os.path.abspath(path)
+
+
+# ── PowerPoint (.pptx) ────────────────────────────────────────────────────
+
+def _export_pptx(session: Session, path: str) -> str:
+    try:
+        from pptx import Presentation
+        from pptx.util import Inches, Pt
+    except ImportError:
+        return (
+            "python-pptx is required for PowerPoint export.\n"
+            "Install: pip install python-pptx"
+        )
+
+    prs = Presentation()
+    blank_layout = prs.slide_layouts[6]  # blank
+    title_layout = prs.slide_layouts[0]  # title slide
+
+    # Slide 1: Title
+    slide = prs.slides.add_slide(title_layout)
+    slide.shapes.title.text = "OpenStat Results"
+    slide.placeholders[1].text = (
+        f"{session.dataset_name or 'Dataset'}  |  {date.today().isoformat()}"
+    )
+
+    # Slide 2: Overview
+    slide = prs.slides.add_slide(prs.slide_layouts[1])
+    slide.shapes.title.text = "Dataset Overview"
+    body = slide.placeholders[1]
+    tf = body.text_frame
+    tf.text = session.shape_str
+    if session.df is not None:
+        df = session.df
+        tf.add_paragraph().text = f"Missing cells: {sum(df[c].null_count() for c in df.columns)}"
+
+    # One slide per model
+    for mr in session.results:
+        slide = prs.slides.add_slide(prs.slide_layouts[1])
+        slide.shapes.title.text = f"{mr.name}: {mr.formula}"
+        tf = slide.placeholders[1].text_frame
+        tf.text = mr.table[:1000]  # truncate if huge
+
+    # One slide per plot
+    for plot_path in session.plot_paths:
+        if os.path.exists(plot_path):
+            slide = prs.slides.add_slide(blank_layout)
+            try:
+                slide.shapes.add_picture(
+                    plot_path,
+                    Inches(0.5), Inches(0.5),
+                    width=Inches(8), height=Inches(5.5),
+                )
+            except Exception:
+                pass
+
+    _ensure_dir(path)
+    prs.save(path)
+    return os.path.abspath(path)
+
+
+# ── Command ────────────────────────────────────────────────────────────────
+
+@command("export", usage="export docx|pptx|pdf|md [path]")
+def cmd_export(session: Session, args: str) -> str:
+    """Export results to Word (.docx), PowerPoint (.pptx), PDF, or Markdown."""
+    ca = CommandArgs(args)
+    if not ca.positional:
+        return "Usage: export docx|pptx|pdf|md [path]"
+
+    fmt = ca.positional[0].lower()
+
+    if fmt == "docx":
+        path = ca.positional[1] if len(ca.positional) > 1 else "outputs/results.docx"
+        out = _export_docx(session, path)
+        if out.endswith(".docx"):
+            return f"Word document saved: {out}"
+        return out
+
+    elif fmt == "pptx":
+        path = ca.positional[1] if len(ca.positional) > 1 else "outputs/results.pptx"
+        out = _export_pptx(session, path)
+        if out.endswith(".pptx"):
+            return f"PowerPoint saved: {out}"
+        return out
+
+    elif fmt == "pdf":
+        from openstat.commands.pdf_cmds import _export_pdf
+        path = ca.positional[1] if len(ca.positional) > 1 else "outputs/results.pdf"
+        out = _export_pdf(session, path)
+        if out.endswith(".pdf"):
+            return f"PDF saved: {out}"
+        return out
+
+    elif fmt == "md":
+        from openstat.commands.pdf_cmds import _export_md
+        path = ca.positional[1] if len(ca.positional) > 1 else "outputs/results.md"
+        out = _export_md(session, path)
+        return f"Markdown saved: {out}"
+
+    else:
+        return f"Unknown export format: {fmt}. Use 'docx', 'pptx', 'pdf', or 'md'."

openstat/commands/export_extra_cmds.py

@@ -0,0 +1,240 @@
+"""Extra export commands: Jupyter notebook, APA text, progress bars."""
+
+from __future__ import annotations
+
+import os
+from datetime import date
+from pathlib import Path
+
+from openstat.commands.base import command, CommandArgs, friendly_error
+from openstat.session import Session
+
+
+# ── Jupyter Notebook export ──────────────────────────────────────────────────
+
+@command("export ipynb", usage="export ipynb [path]")
+def cmd_export_ipynb(session: Session, args: str) -> str:
+    """Export session history as a Jupyter notebook (.ipynb).
+
+    Creates a notebook where each command becomes a code cell with
+    its output. Requires: pip install nbformat
+
+    Examples:
+      export ipynb
+      export ipynb my_analysis.ipynb
+    """
+    try:
+        import nbformat
+        from nbformat.v4 import new_notebook, new_code_cell, new_markdown_cell
+    except ImportError:
+        return "nbformat required. Install: pip install nbformat"
+
+    ca = CommandArgs(args)
+    out_path = ca.positional[0] if ca.positional else "outputs/analysis.ipynb"
+
+    nb = new_notebook()
+    cells = []
+
+    # Title cell
+    cells.append(new_markdown_cell(
+        f"# OpenStat Analysis\n\n"
+        f"**Dataset:** {session.dataset_name or 'Unknown'}  \n"
+        f"**Date:** {date.today().isoformat()}  \n"
+        f"**Shape:** {session.shape_str}"
+    ))
+
+    # Setup cell
+    cells.append(new_code_cell(
+        "# Auto-generated from OpenStat session\n"
+        "# Run: pip install openstat\n"
+        "from openstat.session import Session\n"
+        "from openstat.commands import COMMANDS\n"
+        "session = Session()\n"
+        "\ndef run(cmd):\n"
+        "    parts = cmd.split(None, 1)\n"
+        "    name = parts[0]\n"
+        "    args = parts[1] if len(parts) > 1 else ''\n"
+        "    return COMMANDS[name](session, args)\n"
+    ))
+
+    # One cell per history command
+    for cmd_line in session.history:
+        if cmd_line.strip().startswith("#"):
+            cells.append(new_markdown_cell(cmd_line.lstrip("# ")))
+        else:
+            safe_cmd = cmd_line.replace("'", "\\'")
+            cells.append(new_code_cell(f"print(run('{safe_cmd}'))"))
+
+    # Plots cell
+    if session.plot_paths:
+        plot_code = "from IPython.display import Image, display\n"
+        for p in session.plot_paths:
+            if os.path.exists(p):
+                plot_code += f"display(Image('{p}'))\n"
+        cells.append(new_code_cell(plot_code))
+
+    nb.cells = cells
+    nb.metadata["kernelspec"] = {
+        "display_name": "Python 3",
+        "language": "python",
+        "name": "python3",
+    }
+
+    Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+    with open(out_path, "w", encoding="utf-8") as f:
+        nbformat.write(nb, f)
+
+    n_cells = len(cells)
+    return f"Jupyter notebook saved: {os.path.abspath(out_path)} ({n_cells} cells)"
+
+
+# ── APA export ───────────────────────────────────────────────────────────────
+
+@command("export apa", usage="export apa [path]")
+def cmd_export_apa(session: Session, args: str) -> str:
+    """Export model results in APA 7th edition format.
+
+    Generates text suitable for inclusion in research papers.
+    Supports OLS, logit, probit, and other regression models.
+
+    Examples:
+      ols income educ age
+      export apa
+      export apa results/apa_table.txt
+    """
+    import polars as pl
+
+    ca = CommandArgs(args)
+    out_path = ca.options.get("out")
+
+    lines = [
+        f"APA-Formatted Results",
+        f"Generated: {date.today().isoformat()}",
+        f"Dataset: {session.dataset_name or 'Unknown'} ({session.shape_str})",
+        "",
+    ]
+
+    if not session.results:
+        return "No model results to export. Run ols/logit/etc. first."
+
+    for mr in session.results:
+        model_type = mr.name
+        formula = mr.formula
+        details = mr.details
+
+        n = details.get("n", "?")
+        r2 = details.get("r2")
+        adj_r2 = details.get("adj_r2")
+        f_stat = details.get("f_stat")
+        f_pval = details.get("f_pval")
+        aic = details.get("aic")
+        bic = details.get("bic")
+        ll = details.get("log_likelihood")
+
+        lines.append(f"{'='*60}")
+        lines.append(f"Model: {model_type} — {formula}")
+        lines.append("")
+
+        # APA regression table header
+        if model_type.upper() in ("OLS", "LINEAR"):
+            if r2 is not None:
+                lines.append(
+                    f"A multiple linear regression was conducted to predict {formula.split('~')[0].strip()} "
+                    f"from {formula.split('~')[1].strip() if '~' in formula else 'the predictors'}."
+                )
+                r2_str = f"R² = {r2:.3f}" if r2 is not None else ""
+                adj_r2_str = f", adjusted R² = {adj_r2:.3f}" if adj_r2 is not None else ""
+                f_str = f", F = {f_stat:.2f}" if f_stat is not None else ""
+                p_str = f", p {'< .001' if (f_pval is not None and f_pval < 0.001) else f'= {f_pval:.3f}'}" if f_pval is not None else ""
+                lines.append(f"The model was statistically significant: {r2_str}{adj_r2_str}{f_str}{p_str}.")
+                lines.append(f"N = {n}.")
+        else:
+            if ll is not None:
+                lines.append(f"N = {n}.")
+                if aic is not None:
+                    lines.append(f"AIC = {aic:.2f}, BIC = {bic:.2f}." if bic is not None else f"AIC = {aic:.2f}.")
+
+        lines.append("")
+        lines.append("Table. Regression Coefficients")
+        lines.append(f"  {'Variable':<25} {'B':>10}  {'SE':>8}  {'p':>8}")
+        lines.append("  " + "-" * 55)
+
+        # Parse table for coefficients
+        for line in mr.table.split("\n"):
+            stripped = line.strip()
+            if not stripped or stripped.startswith("=") or stripped.startswith("-"):
+                continue
+            parts = stripped.split()
+            if len(parts) >= 4:
+                try:
+                    coef = float(parts[-4]) if len(parts) >= 4 else float(parts[1])
+                    se = float(parts[-3]) if len(parts) >= 3 else None
+                    p = float(parts[-1]) if len(parts) >= 1 else None
+                    varname = " ".join(parts[:-4]) if len(parts) > 4 else parts[0]
+                    sig = "***" if p is not None and p < 0.001 else "**" if p is not None and p < 0.01 else "*" if p is not None and p < 0.05 else ""
+                    lines.append(f"  {varname:<25} {coef:10.3f}  {se:8.3f}  {p:8.3f}{sig}" if se and p else f"  {varname:<25} {coef:10.3f}")
+                except (ValueError, IndexError):
+                    continue
+
+        lines.append("  " + "-" * 55)
+        lines.append("  Note. * p < .05. ** p < .01. *** p < .001.")
+        lines.append("")
+
+    text = "\n".join(lines)
+
+    if out_path:
+        Path(out_path).parent.mkdir(parents=True, exist_ok=True)
+        Path(out_path).write_text(text, encoding="utf-8")
+        return f"APA results saved: {os.path.abspath(out_path)}"
+
+    if ca.positional:
+        p = ca.positional[0]
+        Path(p).parent.mkdir(parents=True, exist_ok=True)
+        Path(p).write_text(text, encoding="utf-8")
+        return f"APA results saved: {os.path.abspath(p)}"
+
+    return text
+
+
+# ── Progress bar wrapper for long commands ────────────────────────────────────
+
+@command("progress", usage="progress <command with args>")
+def cmd_progress(session: Session, args: str) -> str:
+    """Run a command with a live progress indicator.
+
+    Useful for long-running commands like bootstrap, permtest, hyperopt.
+    Uses rich progress bar.
+
+    Examples:
+      progress bootstrap ols income educ age --reps=2000
+      progress hyperopt income educ age --model=rf --n_iter=50
+    """
+    from openstat.commands.base import run_command
+    from rich.progress import Progress, SpinnerColumn, TextColumn, TimeElapsedColumn
+    import threading
+    import time
+
+    if not args.strip():
+        return "Usage: progress <command> [args]"
+
+    result_holder = {"result": None, "done": False}
+
+    def _run():
+        result_holder["result"] = run_command(session, args.strip())
+        result_holder["done"] = True
+
+    thread = threading.Thread(target=_run, daemon=True)
+
+    with Progress(
+        SpinnerColumn(),
+        TextColumn("[bold blue]{task.description}"),
+        TimeElapsedColumn(),
+        transient=True,
+    ) as prog:
+        task = prog.add_task(f"Running: {args[:50]}...", total=None)
+        thread.start()
+        while not result_holder["done"]:
+            time.sleep(0.1)
+        thread.join()
+
+    return result_holder["result"] or ""

openstat/commands/factor_cmds.py

@@ -0,0 +1,180 @@
+"""Factor analysis and PCA commands."""
+
+from __future__ import annotations
+
+import os
+import re
+
+import numpy as np
+
+from openstat.commands.base import command
+from openstat.session import Session
+from openstat.stats.factor import fit_pca, fit_factor
+
+
+# ── Stata-style arg parser (same as power_cmds) ────────────────────────────
+
+def _stata_parse(raw: str) -> tuple[list[str], dict[str, str], set[str]]:
+    opts: dict[str, str] = {}
+    positional: list[str] = []
+    flags: set[str] = set()
+
+    for m in re.finditer(r'(\w+)\(([^)]*)\)', raw):
+        opts[m.group(1).lower()] = m.group(2)
+
+    rest = re.sub(r'\w+\([^)]*\)', '', raw)
+
+    for tok in rest.split():
+        tok = tok.strip(',')
+        if not tok:
+            continue
+        if '=' in tok:
+            k, v = tok.split('=', 1)
+            opts[k.lower().lstrip('-')] = v
+        elif tok.startswith('--'):
+            flags.add(tok.lstrip('-').lower())
+        elif re.match(r'^\w+$', tok):
+            positional.append(tok)
+
+    return positional, opts, flags
+
+
+def _loadings_table(cols: list[str], loadings: list, blanks: float = 0.0) -> str:
+    arr = np.array(loadings)  # shape (p, k)
+    k = arr.shape[1]
+    header = f"  {'Variable':<15}" + "".join(f"  {'F' + str(i+1):>8}" for i in range(k))
+    lines = [header, "-" * (17 + k * 10)]
+    for i, col in enumerate(cols):
+        row = f"  {col:<15}"
+        for j in range(k):
+            val = arr[i, j]
+            if abs(val) < blanks:
+                row += f"  {'':>8}"
+            else:
+                row += f"  {val:>8.4f}"
+        lines.append(row)
+    return "\n".join(lines)
+
+
+@command("pca", usage="pca varlist [, n(k)]")
+def cmd_pca(session: Session, args: str) -> str:
+    """Principal component analysis."""
+    df = session.require_data()
+    positional, opts, flags = _stata_parse(args)
+    cols = [c for c in positional if c in df.columns]
+    if len(cols) < 2:
+        return "pca requires at least 2 numeric variables."
+
+    n_components = int(opts["n"]) if "n" in opts else None
+
+    result = fit_pca(df, cols, n_components=n_components)
+    session._last_model = result
+    session._last_model_vars = (None, cols)
+
+    eigvals = result["eigenvalues"]
+    evr = result["explained_variance_ratio"]
+    cum = result["cumulative_variance"]
+    loadings = result["loadings"]
+    k = result["n_components"]
+
+    lines = [f"\nPCA — {len(cols)} variables, {k} components", "=" * 55]
+    lines.append(f"  {'Component':<12}  {'Eigenvalue':>12}  {'Var%':>8}  {'Cum%':>8}")
+    lines.append("-" * 55)
+    for i in range(k):
+        lines.append(
+            f"  {'Comp' + str(i+1):<12}  {eigvals[i]:>12.4f}  {evr[i]*100:>7.2f}%  {cum[i]*100:>7.2f}%"
+        )
+    lines.append("=" * 55)
+    lines.append("\nLoadings:")
+    lines.append(_loadings_table(cols, loadings))
+    lines.append("\nRun 'estat screeplot' for a scree plot.")
+    return "\n".join(lines)
+
+
+@command("factor", usage="factor varlist [, n(k) method(pc|ml) --norotate]")
+def cmd_factor(session: Session, args: str) -> str:
+    """Factor analysis with optional varimax rotation."""
+    df = session.require_data()
+    positional, opts, flags = _stata_parse(args)
+    cols = [c for c in positional if c in df.columns]
+    if len(cols) < 2:
+        return "factor requires at least 2 numeric variables."
+
+    n_factors = int(opts.get("n", 2))
+    method = opts.get("method", "pc").lower()
+    rotate = "norotate" not in flags
+
+    result = fit_factor(df, cols, n_factors=n_factors, method=method, rotate=rotate)
+    session._last_model = result
+    session._last_model_vars = (None, cols)
+
+    loadings = result["loadings"]
+    comm = result["communalities"]
+    uniq = result["uniqueness"]
+    k = result["n_factors"]
+    rot_str = " (varimax)" if rotate and k > 1 else ""
+
+    lines = [f"\nFactor Analysis — {method.upper()}{rot_str}", "=" * 60]
+    lines.append("\nLoadings:")
+    lines.append(_loadings_table(cols, loadings))
+    lines.append("\n  " + f"{'Variable':<15}  {'Communality':>12}  {'Uniqueness':>12}")
+    lines.append("  " + "-" * 42)
+    for i, col in enumerate(cols):
+        lines.append(f"  {col:<15}  {comm[i]:>12.4f}  {uniq[i]:>12.4f}")
+    lines.append("\nRun 'estat loadings' or 'estat screeplot' for more detail.")
+    return "\n".join(lines)
+
+
+@command("estat", usage="estat screeplot|loadings [, blanks(0.3)]")
+def cmd_estat(session: Session, args: str) -> str:
+    """Post-estimation: screeplot or loadings table."""
+    positional, opts, flags = _stata_parse(args)
+    sub = positional[0].lower() if positional else ""
+
+    if sub == "screeplot":
+        result = session._last_model
+        if result is None or "eigenvalues" not in result:
+            return "No PCA/factor result in memory. Run 'pca' or 'factor' first."
+
+        eigvals = result["eigenvalues"]
+        lines = ["\nScree Plot", "=" * 50]
+        max_e = max(eigvals) if eigvals else 1
+        for i, e in enumerate(eigvals):
+            bar = int(30 * e / max_e)
+            lines.append(f"  Comp{i+1:>2}  {'█' * bar}  {e:.3f}")
+        lines.append("=" * 50)
+
+        try:
+            import matplotlib.pyplot as plt
+
+            os.makedirs(str(session.output_dir), exist_ok=True)
+            fig, ax = plt.subplots(figsize=(6, 4))
+            ax.plot(range(1, len(eigvals) + 1), eigvals, "o-")
+            ax.axhline(1, linestyle="--", color="red", linewidth=0.8)
+            ax.set_xlabel("Component")
+            ax.set_ylabel("Eigenvalue")
+            ax.set_title("Scree Plot")
+            path = str(session.output_dir / "screeplot.png")
+            fig.savefig(path, dpi=100, bbox_inches="tight")
+            plt.close(fig)
+            session.plot_paths.append(path)
+            lines.append(f"\nScree plot saved: {path}")
+        except Exception:
+            pass
+
+        return "\n".join(lines)
+
+    elif sub == "loadings":
+        result = session._last_model
+        if result is None or "loadings" not in result:
+            return "No PCA/factor result in memory."
+
+        blanks = float(opts.get("blanks", 0.0))
+        cols = result["cols"]
+        loadings = result["loadings"]
+        lines = ["\nFactor/Component Loadings"]
+        lines.append(_loadings_table(cols, loadings, blanks=blanks))
+        return "\n".join(lines)
+
+    else:
+        return f"Unknown estat subcommand: {sub}\nAvailable: screeplot, loadings"