medsci-skills 4.1.0

package/skills/analyze-stats/references/templates/survival_analysis.py

@@ -0,0 +1,325 @@
+"""
+survival_analysis.py — Publication-ready Survival Analysis
+===========================================================
+Kaplan-Meier curves, log-rank test, Cox proportional hazards model.
+
+Input CSV columns:
+    time        : float — Time to event or censoring (in days/months/years)
+    event       : int   — Event indicator (1 = event occurred, 0 = censored)
+    group       : str   — Group variable for KM comparison (optional)
+    [covariates]: float/int — Covariates for Cox model
+
+Outputs:
+    - KM plot with at-risk table (PNG/PDF, 300 DPI)
+    - Cox model results table (CSV)
+    - Console: complete results summary
+
+Usage:
+    python survival_analysis.py --input data.csv \
+        --time time_months --event event \
+        --group treatment_group \
+        --covariates age sex bmi comorbidity \
+        --time-unit "Months" \
+        --output survival_analysis
+
+Dependencies:
+    pip install lifelines pandas numpy matplotlib scipy
+"""
+
+import argparse
+import sys
+from datetime import datetime
+
+import numpy as np
+import pandas as pd
+import matplotlib.pyplot as plt
+import matplotlib.gridspec as gridspec
+
+try:
+    from lifelines import KaplanMeierFitter, CoxPHFitter
+    from lifelines.statistics import logrank_test, multivariate_logrank_test
+    from lifelines.utils import restricted_mean_survival_time, median_survival_times
+    LIFELINES_AVAILABLE = True
+except ImportError:
+    LIFELINES_AVAILABLE = False
+    print("ERROR: lifelines not installed. Install with: pip install lifelines")
+    sys.exit(1)
+
+# ── Reproducibility ───────────────────────────────────────────────────────────
+SCRIPT_VERSION = "1.0.0"
+SEED = 42
+np.random.seed(SEED)
+
+
+def _fmt_time(x):
+    """Format a survival time; 'NR' (not reached) for inf/NaN."""
+    if x is None or not np.isfinite(x):
+        return "NR"
+    return f"{x:.1f}"
+
+
+def median_with_ci(kmf, unit):
+    """Median survival with its 95% CI from a fitted KaplanMeierFitter.
+
+    A median point estimate reported without its CI is incomplete (analyze-stats
+    Survival reporting rule). Returns 'NR' when the median is not reached.
+    """
+    med = kmf.median_survival_time_
+    try:
+        ci = median_survival_times(kmf.confidence_interval_)
+        lo, hi = ci.iloc[0, 0], ci.iloc[0, 1]
+    except Exception:
+        lo = hi = float("nan")
+    return f"{_fmt_time(med)} (95% CI {_fmt_time(lo)}–{_fmt_time(hi)}) {unit}"
+print(f"survival_analysis.py v{SCRIPT_VERSION} | {datetime.now().strftime('%Y-%m-%d')}")
+
+# ── Style ─────────────────────────────────────────────────────────────────────
+plt.rcParams.update({
+    "font.family": "Arial",
+    "font.size": 9,
+    "axes.labelsize": 9,
+    "xtick.labelsize": 8,
+    "ytick.labelsize": 8,
+})
+
+WONG_COLORS = ["#0072B2", "#D55E00", "#009E73", "#E69F00", "#CC79A7", "#56B4E9"]
+LINE_STYLES = ["-", "--", "-.", ":", (0, (3, 1, 1, 1))]
+
+
+def load_data(filepath, time_col, event_col):
+    df = pd.read_csv(filepath)
+    for col in [time_col, event_col]:
+        if col not in df.columns:
+            raise ValueError(f"Column '{col}' not found in {filepath}")
+    df = df.dropna(subset=[time_col, event_col])
+    return df
+
+
+def km_analysis(df, time_col, event_col, group_col=None,
+                time_unit="Months", output_path="survival"):
+    """Kaplan-Meier analysis with at-risk table."""
+    fig = plt.figure(figsize=(7.0, 5.0))
+
+    if group_col and group_col in df.columns:
+        groups = sorted(df[group_col].dropna().unique())
+        n_groups = len(groups)
+        gs = gridspec.GridSpec(2, 1, height_ratios=[3.5, 1.5], hspace=0.05)
+    else:
+        groups = None
+        n_groups = 1
+        gs = gridspec.GridSpec(2, 1, height_ratios=[3.5, 1.5], hspace=0.05)
+
+    ax_km = fig.add_subplot(gs[0])
+    ax_risk = fig.add_subplot(gs[1])
+
+    fitters = {}
+
+    if groups:
+        for i, g in enumerate(groups):
+            mask = df[group_col] == g
+            d = df[mask]
+            kmf = KaplanMeierFitter()
+            kmf.fit(d[time_col], d[event_col], label=str(g))
+            fitters[g] = kmf
+
+            kmf.plot_survival_function(
+                ax=ax_km,
+                color=WONG_COLORS[i % len(WONG_COLORS)],
+                linestyle=LINE_STYLES[i % len(LINE_STYLES)],
+                linewidth=1.5,
+                ci_show=True,
+                ci_alpha=0.15,
+            )
+
+            # Median survival with 95% CI
+            print(f"  {g}: Median survival = {median_with_ci(kmf, time_unit)}")
+
+        # Log-rank test
+        if n_groups == 2:
+            g1, g2 = groups
+            lr = logrank_test(
+                df.loc[df[group_col] == g1, time_col],
+                df.loc[df[group_col] == g2, time_col],
+                df.loc[df[group_col] == g1, event_col],
+                df.loc[df[group_col] == g2, event_col],
+            )
+            p_str = f"P {'< .001' if lr.p_value < 0.001 else f'= {lr.p_value:.3f}'}"
+            ax_km.text(0.98, 0.5, f"Log-rank {p_str}",
+                       transform=ax_km.transAxes, fontsize=8,
+                       va="center", ha="right")
+            print(f"\n  Log-rank test: χ² = {lr.test_statistic:.3f}, P = {lr.p_value:.4f}")
+        else:
+            mlr = multivariate_logrank_test(
+                df[time_col], df[group_col], df[event_col]
+            )
+            p_str = f"P {'< .001' if mlr.p_value < 0.001 else f'= {mlr.p_value:.3f}'}"
+            ax_km.text(0.98, 0.5, f"Log-rank {p_str}",
+                       transform=ax_km.transAxes, fontsize=8,
+                       va="center", ha="right")
+    else:
+        # Single-group KM
+        kmf = KaplanMeierFitter()
+        kmf.fit(df[time_col], df[event_col], label="All patients")
+        fitters["All"] = kmf
+        kmf.plot_survival_function(ax=ax_km, color=WONG_COLORS[0],
+                                    linewidth=1.5, ci_show=True, ci_alpha=0.2)
+        print(f"  Median survival: {median_with_ci(kmf, time_unit)}")
+
+    # KM axis formatting
+    ax_km.set_ylim(-0.02, 1.05)
+    ax_km.set_xlim(left=0)
+    ax_km.set_ylabel("Survival probability", fontsize=9)
+    ax_km.set_xlabel("")
+    ax_km.spines[["top", "right"]].set_visible(False)
+    ax_km.legend(fontsize=8, frameon=False)
+    ax_km.grid(axis="y", color="#EEEEEE", linewidth=0.5)
+
+    # At-risk table
+    ax_risk.set_axis_off()
+    time_points = np.linspace(0, df[time_col].max() * 0.95, 6)
+    row_offset = 1.0
+
+    for i, (label, kmf) in enumerate(fitters.items()):
+        at_risk = [kmf.event_table["at_risk"].iloc[
+            max(0, (kmf.event_table.index <= t).sum() - 1)
+        ] for t in time_points]
+        ax_risk.text(-0.01, row_offset - i * 0.35, str(label),
+                     transform=ax_risk.transAxes, fontsize=7.5,
+                     va="top", ha="right",
+                     color=WONG_COLORS[i % len(WONG_COLORS)])
+        for j, (t, n) in enumerate(zip(time_points, at_risk)):
+            ax_risk.text(j / (len(time_points) - 1), row_offset - i * 0.35,
+                          str(int(n)), transform=ax_risk.transAxes,
+                          fontsize=7.5, va="top", ha="center")
+
+    ax_km.set_xticks(time_points)
+    ax_km.set_xlabel(time_unit, fontsize=9)
+
+    plt.suptitle("Kaplan-Meier Survival Curves", fontsize=10, y=1.01, fontweight="bold")
+    plt.tight_layout()
+
+    for ext in ["pdf", "png"]:
+        outfile = f"{output_path}_km.{ext}"
+        dpi = 300 if ext == "png" else None
+        plt.savefig(outfile, dpi=dpi, bbox_inches="tight",
+                    facecolor="white", edgecolor="none")
+        print(f"Saved: {outfile}")
+    plt.close()
+
+
+def cox_analysis(df, time_col, event_col, covariates, output_path="survival",
+                 cluster_col=None):
+    """Cox proportional hazards model.
+
+    cluster_col: id column for nested observation units (e.g. multiple lesions /
+    eyes / repeated episodes per subject). When set, lifelines computes a robust
+    (cluster-sandwich) variance so the HR CIs reflect within-subject correlation
+    rather than treating correlated rows as independent.
+    """
+    keep = [time_col, event_col] + covariates + ([cluster_col] if cluster_col else [])
+    model_df = df[keep].dropna()
+    print(f"\n── Cox PH Model (N = {len(model_df)}) ───────────────────────")
+
+    # Events-per-variable (EPV) gate — mirror of the logistic EPV rule. A Wald CI
+    # from a sparse-event model is not stable; warn and rely on the penalizer.
+    n_events = int(model_df[event_col].sum())
+    epv = n_events / max(len(covariates), 1)
+    print(f"EPV = {epv:.1f} ({n_events} events / {len(covariates)} covariates; "
+          f"minimum recommended: 10)")
+    if epv < 10:
+        print("⚠ WARNING: EPV < 10 — Cox estimates may be unstable. The penalized "
+              "fit (penalizer=0.1) shrinks coefficients; consider Firth/penalized "
+              "Cox or profile-likelihood CIs and interpret Wald CIs with caution.")
+
+    cph = CoxPHFitter(penalizer=0.1)
+    fit_kw = {"duration_col": time_col, "event_col": event_col}
+    if cluster_col:
+        fit_kw["cluster_col"] = cluster_col  # robust (cluster-sandwich) SE
+        print(f"Robust cluster-sandwich SE on '{cluster_col}' (nested units).")
+    cph.fit(model_df, **fit_kw)
+    cph.print_summary()
+
+    # Check PH assumption
+    print("\n── Proportional Hazards Assumption (Schoenfeld residuals) ───")
+    try:
+        cph.check_assumptions(model_df, p_value_threshold=0.05, show_plots=False)
+    except Exception as e:
+        print(f"  PH assumption check: {e}")
+
+    # Save results table
+    summary = cph.summary.copy()
+    summary.columns = [c.replace(" ", "_") for c in summary.columns]
+    outfile = f"{output_path}_cox_results.csv"
+    summary.to_csv(outfile)
+    print(f"\nSaved: {outfile}")
+
+    # Concordance index
+    print(f"\nConcordance index (C-statistic): {cph.concordance_index_:.3f}")
+
+    return cph
+
+
+def rmst_analysis(df, time_col, event_col, group_col, t_star, output_path="survival"):
+    """Restricted Mean Survival Time analysis."""
+    if group_col not in df.columns:
+        return
+
+    groups = df[group_col].dropna().unique()
+    print(f"\n── Restricted Mean Survival Time (t* = {t_star}) ────────────")
+    for g in groups:
+        d = df[df[group_col] == g]
+        kmf = KaplanMeierFitter()
+        kmf.fit(d[time_col], d[event_col])
+        rmst = restricted_mean_survival_time(kmf, t=t_star)
+        print(f"  {g}: RMST = {rmst:.2f}")
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Survival analysis")
+    parser.add_argument("--input", required=True)
+    parser.add_argument("--time", required=True, help="Time column name")
+    parser.add_argument("--event", required=True, help="Event column name (1=event, 0=censored)")
+    parser.add_argument("--group", default=None)
+    parser.add_argument("--covariates", nargs="+", default=None)
+    parser.add_argument("--cluster", default=None,
+                        help="ID column for nested units → robust cluster SE in Cox")
+    parser.add_argument("--time-unit", default="Months")
+    parser.add_argument("--rmst-t", type=float, default=None,
+                        help="t* for RMST (in same units as time)")
+    parser.add_argument("--output", default="survival_analysis")
+
+    args = parser.parse_args()
+
+    df = load_data(args.input, args.time, args.event)
+    print(f"\nN = {len(df)} | Events: {df[args.event].sum()} "
+          f"({df[args.event].mean()*100:.1f}%)")
+
+    print("\n── Kaplan-Meier Analysis ────────────────────")
+    km_analysis(df, args.time, args.event, args.group,
+                args.time_unit, args.output)
+
+    if args.covariates:
+        cox_analysis(df, args.time, args.event, args.covariates, args.output,
+                     cluster_col=args.cluster)
+
+    if args.rmst_t and args.group:
+        rmst_analysis(df, args.time, args.event, args.group,
+                      args.rmst_t, args.output)
+
+    print(f"\n── Session Info ─────────────────────────────")
+    print(f"Python: {sys.version.split()[0]}")
+    for pkg in ["lifelines", "pandas", "numpy", "scipy"]:
+        try:
+            import importlib
+            m = importlib.import_module(pkg)
+            print(f"  {pkg}: {m.__version__}")
+        except Exception:
+            pass
+
+
+if __name__ == "__main__":
+    if len(sys.argv) == 1:
+        print("Usage: python survival_analysis.py --input data.csv "
+              "--time time_months --event event --group treatment")
+    else:
+        main()

package/skills/analyze-stats/references/templates/table1_demographics.py

@@ -0,0 +1,287 @@
+"""
+Template: Table 1 — Baseline Demographics
+Generates a publication-ready demographics table from tabular data.
+
+Usage:
+    Modify the CONFIGURATION section below, then run:
+        python table1_demographics.py
+
+Input:  CSV or Excel file with one row per subject
+Output: table1_demographics.csv, table1_demographics.md (console), summary text
+"""
+
+# === REPRODUCIBILITY HEADER ===
+import sys
+import datetime
+import numpy as np
+import pandas as pd
+from scipy import stats
+
+np.random.seed(42)
+print(f"Date: {datetime.date.today()}")
+print(f"Python: {sys.version}")
+print(f"numpy: {np.__version__}, pandas: {pd.__version__}, scipy: {stats.scipy.__version__}")
+print()
+
+# === CONFIGURATION (modify for your study) ===
+INPUT_FILE = "data.csv"           # Path to input data
+OUTPUT_DIR = "."                  # Output directory
+GROUP_COL = None                  # Column name for group comparison (None = no comparison)
+CONTINUOUS_VARS = []              # List of continuous variable column names
+CATEGORICAL_VARS = []            # List of categorical variable column names
+VAR_LABELS = {}                   # Optional display labels: {"col_name": "Display Name (unit)"}
+DECIMAL_PLACES = 1                # Decimal places for continuous variables
+# ==============================================
+
+
+def load_data(filepath: str) -> pd.DataFrame:
+    """Load CSV or Excel file."""
+    if filepath.endswith((".xlsx", ".xls")):
+        return pd.read_excel(filepath)
+    return pd.read_csv(filepath)
+
+
+def test_normality(series: pd.Series, alpha: float = 0.05) -> tuple:
+    """Test normality using Shapiro-Wilk (n<50) or Kolmogorov-Smirnov (n>=50)."""
+    clean = series.dropna()
+    if len(clean) < 3:
+        return False, np.nan
+    if len(clean) < 50:
+        stat, p = stats.shapiro(clean)
+    else:
+        stat, p = stats.kstest(clean, "norm", args=(clean.mean(), clean.std()))
+    return p >= alpha, p
+
+
+def format_continuous(series: pd.Series, is_normal: bool, dp: int = 1) -> str:
+    """Format continuous variable as mean +/- SD or median (IQR)."""
+    clean = series.dropna()
+    if is_normal:
+        return f"{clean.mean():.{dp}f} +/- {clean.std():.{dp}f}"
+    else:
+        q1, median, q3 = clean.quantile([0.25, 0.5, 0.75])
+        return f"{median:.{dp}f} ({q1:.{dp}f}-{q3:.{dp}f})"
+
+
+def format_categorical(series: pd.Series) -> dict:
+    """Format categorical variable as n (%)."""
+    counts = series.value_counts(dropna=False)
+    total = len(series)
+    result = {}
+    for cat, n in counts.items():
+        pct = 100.0 * n / total if total > 0 else 0.0
+        label = str(cat) if pd.notna(cat) else "Missing"
+        result[label] = f"{n} ({pct:.1f}%)"
+    return result
+
+
+def compare_continuous(groups: list, is_normal: bool) -> tuple:
+    """Compare continuous variable between groups."""
+    clean_groups = [g.dropna() for g in groups]
+    if len(clean_groups) == 2:
+        if is_normal:
+            stat, p = stats.ttest_ind(*clean_groups)
+            return "t-test", p
+        else:
+            stat, p = stats.mannwhitneyu(*clean_groups, alternative="two-sided")
+            return "Mann-Whitney U", p
+    else:
+        if is_normal:
+            stat, p = stats.f_oneway(*clean_groups)
+            return "ANOVA", p
+        else:
+            stat, p = stats.kruskal(*clean_groups)
+            return "Kruskal-Wallis", p
+
+
+def compare_categorical(contingency: pd.DataFrame) -> tuple:
+    """Compare categorical variable between groups using chi-square or Fisher's exact."""
+    table = contingency.values
+    # Use Fisher's exact test for 2x2 tables with any expected count < 5
+    if table.shape == (2, 2):
+        expected = stats.chi2_contingency(table, correction=False)[3]
+        if (expected < 5).any():
+            odds_ratio, p = stats.fisher_exact(table)
+            return "Fisher's exact", p
+    # Otherwise chi-square (with Yates' correction for 2x2)
+    chi2, p, dof, expected = stats.chi2_contingency(table)
+    if (expected < 5).any():
+        print(f"  Warning: expected counts < 5 in some cells; consider collapsing categories.")
+    return "Chi-square", p
+
+
+def format_p(p: float) -> str:
+    """Format p-value per reporting rules."""
+    if pd.isna(p):
+        return ""
+    if p < 0.001:
+        return "<0.001"
+    return f"{p:.3f}"
+
+
+def build_table1(df: pd.DataFrame) -> pd.DataFrame:
+    """Build the full Table 1 dataframe."""
+    rows = []
+    test_footnotes = set()
+
+    if GROUP_COL and GROUP_COL in df.columns:
+        groups = df[GROUP_COL].dropna().unique()
+        groups = sorted(groups, key=str)
+        group_dfs = {str(g): df[df[GROUP_COL] == g] for g in groups}
+    else:
+        groups = []
+        group_dfs = {}
+
+    n_row = {"Variable": "n"}
+    if group_dfs:
+        for g_name, g_df in group_dfs.items():
+            n_row[g_name] = str(len(g_df))
+    n_row["Overall"] = str(len(df))
+    if group_dfs:
+        n_row["p-value"] = ""
+        n_row["Test"] = ""
+    rows.append(n_row)
+
+    # --- Continuous variables ---
+    for var in CONTINUOUS_VARS:
+        if var not in df.columns:
+            print(f"Warning: '{var}' not found in data, skipping.")
+            continue
+        label = VAR_LABELS.get(var, var)
+        is_normal, norm_p = test_normality(df[var])
+        stat_type = "mean +/- SD" if is_normal else "median (IQR)"
+
+        row = {"Variable": f"{label}, {stat_type}"}
+        row["Overall"] = format_continuous(df[var], is_normal, DECIMAL_PLACES)
+
+        if group_dfs:
+            for g_name, g_df in group_dfs.items():
+                row[g_name] = format_continuous(g_df[var], is_normal, DECIMAL_PLACES)
+            grp_series = [g_df[var] for g_df in group_dfs.values()]
+            test_name, p_val = compare_continuous(grp_series, is_normal)
+            row["p-value"] = format_p(p_val)
+            row["Test"] = test_name
+            test_footnotes.add(test_name)
+
+        rows.append(row)
+
+    # --- Categorical variables ---
+    for var in CATEGORICAL_VARS:
+        if var not in df.columns:
+            print(f"Warning: '{var}' not found in data, skipping.")
+            continue
+        label = VAR_LABELS.get(var, var)
+
+        # Header row for this variable
+        header_row = {"Variable": f"{label}, n (%)"}
+
+        if group_dfs:
+            contingency = pd.crosstab(df[var], df[GROUP_COL])
+            test_name, p_val = compare_categorical(contingency)
+            header_row["p-value"] = format_p(p_val)
+            header_row["Test"] = test_name
+            test_footnotes.add(test_name)
+            for g_name in group_dfs:
+                header_row[g_name] = ""
+        header_row["Overall"] = ""
+        rows.append(header_row)
+
+        # Category rows
+        all_cats = format_categorical(df[var])
+        for cat_label, cat_val in all_cats.items():
+            cat_row = {"Variable": f"  {cat_label}"}
+            cat_row["Overall"] = cat_val
+            if group_dfs:
+                for g_name, g_df in group_dfs.items():
+                    cat_counts = format_categorical(g_df[var])
+                    cat_row[g_name] = cat_counts.get(cat_label, "0 (0.0%)")
+                cat_row["p-value"] = ""
+                cat_row["Test"] = ""
+            rows.append(cat_row)
+
+    # Build dataframe
+    table_df = pd.DataFrame(rows)
+
+    # Reorder columns
+    col_order = ["Variable"]
+    if group_dfs:
+        col_order += [str(g) for g in sorted(groups, key=str)]
+    col_order += ["Overall"]
+    if group_dfs:
+        col_order += ["p-value", "Test"]
+    table_df = table_df[col_order]
+
+    print("\n--- Test Methods Used ---")
+    for t in sorted(test_footnotes):
+        print(f"  - {t}")
+    print()
+
+    return table_df
+
+
+def save_outputs(table_df: pd.DataFrame) -> None:
+    """Save table as CSV and print markdown version."""
+    import os
+    csv_path = os.path.join(OUTPUT_DIR, "table1_demographics.csv")
+
+    # Save CSV (without Test column for manuscript)
+    export_df = table_df.drop(columns=["Test"], errors="ignore")
+    export_df.to_csv(csv_path, index=False)
+    print(f"Saved: {csv_path}")
+
+    # Print markdown table
+    print("\n--- Table 1. Baseline Characteristics ---\n")
+    print(export_df.to_markdown(index=False))
+
+
+def print_results_text(df: pd.DataFrame, table_df: pd.DataFrame) -> None:
+    """Print copy-paste-ready text for Results section."""
+    print("\n--- Results Text (copy-paste ready) ---\n")
+    n_total = len(df)
+
+    if GROUP_COL and GROUP_COL in df.columns:
+        groups = df[GROUP_COL].dropna().unique()
+        group_counts = df[GROUP_COL].value_counts()
+        parts = [f"{g} (n = {group_counts[g]})" for g in sorted(groups, key=str)]
+        print(f"A total of {n_total} subjects were included and divided into "
+              f"{len(groups)} groups: {', '.join(parts)}. "
+              f"Baseline characteristics are summarized in Table 1.")
+    else:
+        print(f"A total of {n_total} subjects were included. "
+              f"Baseline characteristics are summarized in Table 1.")
+
+    # Report missing data
+    missing = df[CONTINUOUS_VARS + CATEGORICAL_VARS].isnull().sum()
+    missing = missing[missing > 0]
+    if len(missing) > 0:
+        print(f"\nMissing data: ", end="")
+        parts = [f"{VAR_LABELS.get(col, col)}: {n} ({100*n/len(df):.1f}%)"
+                 for col, n in missing.items()]
+        print("; ".join(parts) + ".")
+
+
+# === MAIN ===
+if __name__ == "__main__":
+    print("=" * 60)
+    print("Table 1: Baseline Demographics")
+    print("=" * 60)
+
+    df = load_data(INPUT_FILE)
+    print(f"\nLoaded: {INPUT_FILE} ({df.shape[0]} rows, {df.shape[1]} columns)")
+
+    # Auto-detect if CONTINUOUS_VARS and CATEGORICAL_VARS are empty
+    if not CONTINUOUS_VARS and not CATEGORICAL_VARS:
+        print("\nNo variables specified. Auto-detecting from data types...")
+        for col in df.columns:
+            if col == GROUP_COL:
+                continue
+            if pd.api.types.is_numeric_dtype(df[col]) and df[col].nunique() > 10:
+                CONTINUOUS_VARS.append(col)
+                print(f"  Continuous: {col}")
+            elif df[col].nunique() <= 20:
+                CATEGORICAL_VARS.append(col)
+                print(f"  Categorical: {col}")
+
+    table_df = build_table1(df)
+    save_outputs(table_df)
+    print_results_text(df, table_df)