bossanova 0.1.0.dev17__tar.gz → 0.1.0.dev19__tar.gz

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/.gitignore

@@ -78,7 +78,7 @@ COMPARISON-REPORT.md
 ERROR_MESSAGE_IMPROVEMENTS.md
 *.qmd
 bossanova-docs/apidocs/
-bossanova-docs/help/
+bossanova-docs/api/
 bossanova-docs/wip/
 .hypothesis/
 research.md

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bossanova
-Version: 0.1.0.dev17
+Version: 0.1.0.dev19
 Summary: Bridging statistical cultures with some jazz
 Author: Eshin Jolly
 License-Expression: MIT
@@ -70,4 +70,19 @@ m.explore("Days")
 m.effects
 ```
 
+## Development
+
+```bash
+# Install dependencies
+pixi install
+
+# Install the IPython kernel (required for notebooks)
+pixi run setup-kernel
+
+# Run the full lint + type-check chain
+pixi run lint
+
+# Run fast unit tests
+pixi run test
+```
 

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/README.md

@@ -42,4 +42,19 @@ m.explore("Days")
 m.effects
 ```
 
+## Development
+
+```bash
+# Install dependencies
+pixi install
+
+# Install the IPython kernel (required for notebooks)
+pixi run setup-kernel
+
+# Run the full lint + type-check chain
+pixi run lint
+
+# Run fast unit tests
+pixi run test
+```
 

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/__init__.py

@@ -31,11 +31,14 @@ from bossanova.data import (  # noqa: E402
 from bossanova.model import model  # noqa: E402
 
 # Statistics
-from bossanova.internal.operations.compare import compare, lrt  # noqa: E402
+from bossanova.internal.compare import compare, lrt  # noqa: E402
 
 # Visualization
 from bossanova.internal import viz  # noqa: E402
 
+# Export utilities
+from bossanova.internal.rendering.markdown import to_markdown  # noqa: E402
+
 # Expressions
 from bossanova import expressions  # noqa: E402
 
@@ -53,6 +56,7 @@ __all__ = [
     "set_display_digits",
     "set_singular_tolerance",
     "show_datasets",
+    "to_markdown",
     "viz",
 ]
 

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/data/__init__.py

@@ -1,4 +1,20 @@
-"""Bundled sample datasets for regression and mixed-effects modeling."""
+"""Bundled sample datasets for regression and mixed-effects modeling.
+
+| Dataset | Argument | Description |
+|---------|----------|-------------|
+| Advertising | `"advertising"` | TV, radio, newspaper ad spend vs sales (200 x 4) |
+| Cake | `"cake"` | Baking angle by recipe and temperature (270 x 5) |
+| ChickWeight | `"chickweight"` | Chick weight over time by diet (578 x 4) |
+| Credit | `"credit"` | Credit card balance by income and demographics (400 x 11) |
+| Gammas | `"gammas"` | Simulated BOLD signal for Gamma GLM (6000 x 4) |
+| mtcars | `"mtcars"` | Motor Trend car road tests (32 x 12) |
+| Penguins | `"penguins"` | Palmer Penguins body measurements (344 x 8) |
+| Poker | `"poker"` | Poker hand outcomes by skill and limit (300 x 4) |
+| Sleep | `"sleep"` | Reaction time vs sleep deprivation (180 x 3) |
+| Titanic | `"titanic"` | Passenger survival with demographics (891 x 15) |
+| Titanic Train | `"titanic_train"` | Titanic training set, Kaggle format (891 x 12) |
+| Titanic Test | `"titanic_test"` | Titanic test set, Kaggle format (418 x 11) |
+"""
 
 from importlib.resources import files
 from typing import Literal
@@ -52,7 +68,7 @@ def show_datasets() -> pl.DataFrame:
         ```python
         from bossanova.data import show_datasets
         show_datasets()
-        # shape: (11, 2)
+        # shape: (12, 2)
         # ┌───────────────┬─────────────────────────────────┐
         # │ name          ┆ description                     │
         # │ ---           ┆ ---                             │

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/expressions.py

@@ -2,19 +2,19 @@
 
 This module provides stateless Polars expressions for data transformations
 commonly used in statistical modeling. These match the semantics of the
-formula-based transforms in `bossanova.internal.operations.formula`.
-
-Core Transforms:
-    center(col): x - mean(x) — subtract mean only
-    norm(col): x / std(x) — divide by std only (normalize magnitude)
-    zscore(col): (x - mean(x)) / std(x) — traditional z-score (1 SD)
-    scale(col): (x - mean(x)) / (2 * std(x)) — Gelman scaling (2 SD)
-
-Additional Helpers:
-    rank(col, method): Average-method rank transform (matches R's rank())
-    winsorize(col, lower, upper): Percentile capping for outliers
-    lag(col, n): Lagged (shifted backward) values
-    lead(col, n): Lead (shifted forward) values
+formula-based transforms in `bossanova.internal.formula`.
+
+**Core Transforms:**
+- `center(col)` — subtract mean only
+- `norm(col)` — divide by std only
+- `zscore(col)` — traditional z-score (1 SD)
+- `scale(col)` — Gelman scaling (2 SD)
+
+**Additional Helpers:**
+- `rank(col, method)` — average-method rank transform
+- `winsorize(col, lower, upper)` — percentile capping
+- `lag(col, n)` — lagged values
+- `lead(col, n)` — lead values
 
 The scale() transform follows Gelman (2008) recommendation to divide by
 2 standard deviations, making continuous predictor coefficients directly

bossanova-0.1.0.dev19/bossanova/internal/compare/__init__.py

@@ -0,0 +1,12 @@
+"""Model comparison: information criteria, likelihood ratio tests, and composite tables.
+
+Call chain:
+    bossanova.compare(m1, m2, ...) -> compare() (composite AIC/BIC/loglik table)
+    bossanova.lrt(m1, m2) -> lrt() (nested model likelihood ratio test)
+"""
+
+from bossanova.internal.compare.compare import compare
+from bossanova.internal.compare.ic import compare_aic, compare_bic
+from bossanova.internal.compare.lrt import lrt
+
+__all__ = ["compare", "compare_aic", "compare_bic", "lrt"]

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/compare.py

@@ -35,16 +35,17 @@ import polars as pl
 
 from bossanova.internal.maths.config import get_display_digits
 from bossanova.internal.maths.rounding import round_float_columns
-from bossanova.internal.operations.compare.cv import compare_cv
-from bossanova.internal.operations.compare.deviance import compare_deviance
-from bossanova.internal.operations.compare.f_test import compare_f_test
-from bossanova.internal.operations.compare.helpers import (
-    infer_method,
+from bossanova.internal.compare.cv import compare_cv
+from bossanova.internal.compare.deviance import compare_deviance
+from bossanova.internal.compare.f_test import compare_f_test
+from bossanova.internal.compare.helpers import (
+    resolve_method,
     sort_models_by_complexity,
     validate_models,
 )
-from bossanova.internal.operations.compare.lrt_compare import compare_lrt
-from bossanova.internal.operations.compare.refit import refit_with_ml
+from bossanova.internal.compare.ic import compare_aic, compare_bic
+from bossanova.internal.compare.lrt_compare import compare_lrt
+from bossanova.internal.compare.refit import refit_with_ml
 
 __all__ = ["compare"]
 
@@ -78,6 +79,8 @@ def compare(
             - "lrt": Likelihood ratio test (for mixed models)
             - "deviance": Deviance test (for glm)
             - "cv": Cross-validation comparison (for lm/glm)
+            - "aic": AIC comparison with delta-AIC and Akaike weights
+            - "bic": BIC comparison with delta-BIC and Schwarz weights
         sort: If True, sort models by complexity before comparing.
             This ensures proper nesting order.
         refit: If True and models are lmer/glmer with REML estimation,
@@ -140,6 +143,15 @@ def compare(
             - diff_se: Nadeau-Bengio corrected standard error
             - p_value: Two-sided p-value
 
+        For AIC/BIC comparison:
+            - model: Formula string
+            - npar: Number of estimated parameters
+            - loglik: Log-likelihood
+            - deviance: Deviance (-2 * loglik)
+            - AIC/BIC: Information criteria
+            - delta_AIC/delta_BIC: Difference from best model
+            - weight: Akaike/Schwarz weight (model probability)
+
     Raises:
         ValueError: If models are not valid for comparison.
 
@@ -211,15 +223,15 @@ def compare(
     # Validate and auto-fit models (pass method and refit for REML check)
     models = validate_models(models, method=method, refit=refit)
 
-    # Sort if requested (not applicable for CV)
-    if sort and method != "cv":
+    # Sort if requested (not applicable for CV or IC methods which sort internally)
+    if sort and method not in ("cv", "aic", "bic"):
         model_list = sort_models_by_complexity(models)
     else:
         model_list = list(models)
 
     # Infer method if auto
     if method == "auto":
-        method = infer_method(model_list[0])
+        method = resolve_method(model_list[0])
 
     # For LRT with refit=True, refit REML models with ML
     if method == "lrt" and refit:
@@ -234,9 +246,14 @@ def compare(
         result = compare_deviance(model_list, test=test)
     elif method == "cv":
         result = compare_cv(model_list, cv=cv, seed=seed, metric=metric)
+    elif method == "aic":
+        result = compare_aic(model_list)
+    elif method == "bic":
+        result = compare_bic(model_list)
     else:
         raise ValueError(
-            f"Unknown method: {method}. Use 'auto', 'f', 'lrt', 'deviance', or 'cv'."
+            f"Unknown method: {method}. "
+            "Use 'auto', 'f', 'lrt', 'deviance', 'cv', 'aic', or 'bic'."
         )
 
     # Round float columns to significant figures (digits=0 disables rounding)

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/cv.py

@@ -13,19 +13,19 @@ from scipy import stats
 
 from bossanova.internal.containers.schemas import Col, ComparisonCv
 from bossanova.internal.maths.rng import RNG
-from bossanova.internal.operations.compare.helpers import get_model_type
-from bossanova.internal.operations.resample.core import (
+from bossanova.internal.compare.helpers import get_model_type
+from bossanova.internal.infer.resample.core import (
     generate_kfold_indices,
     generate_loo_indices,
 )
 
 __all__ = [
     "compare_cv",
-    "cv_fold_score",
+    "compute_cv_fold_score",
 ]
 
 
-def cv_fold_score(
+def compute_cv_fold_score(
     model: Any,
     train_idx: np.ndarray,
     test_idx: np.ndarray,
@@ -142,7 +142,7 @@ def compare_cv(
 
     for train_idx, test_idx in splits:
         for i, model in enumerate(models):
-            score = cv_fold_score(model, train_idx, test_idx, metric)
+            score = compute_cv_fold_score(model, train_idx, test_idx, metric)
             fold_scores[i].append(score)
 
     # Convert to arrays

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/deviance.py

@@ -14,7 +14,7 @@ from bossanova.internal.containers.schemas import (
     ComparisonDevianceChi2,
     ComparisonDevianceF,
 )
-from bossanova.internal.operations.compare.helpers import check_nested
+from bossanova.internal.compare.helpers import check_nested
 
 __all__ = [
     "compare_deviance",

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/f_test.py

@@ -10,7 +10,7 @@ import polars as pl
 from scipy import stats
 
 from bossanova.internal.containers.schemas import Col, ComparisonFTest
-from bossanova.internal.operations.compare.helpers import check_nested
+from bossanova.internal.compare.helpers import check_nested
 
 __all__ = [
     "compare_f_test",

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/helpers.py

@@ -15,7 +15,7 @@ if TYPE_CHECKING:
 __all__ = [
     "check_nested",
     "get_model_type",
-    "infer_method",
+    "resolve_method",
     "sort_models_by_complexity",
     "validate_models",
 ]
@@ -100,7 +100,7 @@ def validate_models(
 
     # For LRT, check that all models use ML estimation (unless refit=True)
     model_type = model_types[0]
-    inferred_method = method if method != "auto" else infer_method(models[0])
+    inferred_method = method if method != "auto" else resolve_method(models[0])
 
     if inferred_method == "lrt" and model_type in ("lmer", "glmer") and not refit:
         methods = [m._spec.method for m in models]
@@ -151,7 +151,7 @@ def sort_models_by_complexity(models: tuple[Any, ...]) -> list[Any]:
     return sorted(models, key=get_total_params)
 
 
-def infer_method(model: Any) -> str:
+def resolve_method(model: Any) -> str:
     """Infer the appropriate comparison method for a model type.
 
     Uses :func:`classify_model_type` to canonically determine the model type

bossanova-0.1.0.dev19/bossanova/internal/compare/ic.py

@@ -0,0 +1,160 @@
+"""Information criterion comparison for model selection.
+
+Computes AIC/BIC tables with delta-IC and Akaike/Schwarz weights,
+following Burnham & Anderson (2002). Unlike hypothesis-test comparisons
+(F-test, LRT, deviance), IC comparison does not require model nesting —
+any set of models fitted to the same data can be compared.
+
+Functions:
+    compare_aic: Rank models by AIC with delta-AIC and Akaike weights.
+    compare_bic: Rank models by BIC with delta-BIC and Schwarz weights.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+import polars as pl
+
+from bossanova.internal.containers.schemas import (
+    Col,
+    ComparisonAic,
+    ComparisonBic,
+)
+from bossanova.internal.maths.family import ESTIMATED_DISPERSION_FAMILIES
+from bossanova.internal.maths.inference import compute_aic, compute_bic
+
+__all__ = ["compare_aic", "compare_bic"]
+
+
+def _get_n_params_ic(model: Any) -> int:
+    """Get total number of estimated parameters for IC computation.
+
+    Follows the same counting as ``compute_diagnostics()``:
+
+    - ``rank`` (estimable fixed effects)
+    - ``+ len(theta)`` for mixed models (variance parameters)
+    - ``+ 1`` for families with estimated dispersion (e.g. Gaussian sigma)
+
+    Args:
+        model: A fitted model instance.
+
+    Returns:
+        Total parameter count for AIC/BIC computation.
+    """
+    k: int = model._bundle.rank
+    if model._fit.theta is not None:
+        k += len(model._fit.theta)
+    if model._spec.family in ESTIMATED_DISPERSION_FAMILIES:
+        k += 1
+    return k
+
+
+def compare_aic(models: list[Any]) -> pl.DataFrame:
+    """Compare models by AIC with delta-AIC and Akaike weights.
+
+    Models are sorted by AIC (best first). Delta-AIC is the difference
+    from the best model. Akaike weights represent the relative likelihood
+    of each model being the best, following Burnham & Anderson (2002):
+
+        w_i = exp(-0.5 * delta_i) / sum(exp(-0.5 * delta_j))
+
+    Args:
+        models: List of fitted model objects (at least 2).
+
+    Returns:
+        DataFrame with columns: model, npar, loglik, deviance, AIC, BIC,
+        delta_AIC, weight. Sorted by AIC ascending (best model first).
+    """
+    return _compare_ic(models, criterion="aic")
+
+
+def compare_bic(models: list[Any]) -> pl.DataFrame:
+    """Compare models by BIC with delta-BIC and Schwarz weights.
+
+    Models are sorted by BIC (best first). Delta-BIC is the difference
+    from the best model. Schwarz weights use the same formula as Akaike
+    weights but applied to BIC differences.
+
+    Args:
+        models: List of fitted model objects (at least 2).
+
+    Returns:
+        DataFrame with columns: model, npar, loglik, deviance, AIC, BIC,
+        delta_BIC, weight. Sorted by BIC ascending (best model first).
+    """
+    return _compare_ic(models, criterion="bic")
+
+
+def _compare_ic(models: list[Any], *, criterion: str) -> pl.DataFrame:
+    """Shared implementation for AIC/BIC comparison.
+
+    Args:
+        models: List of fitted models.
+        criterion: ``"aic"`` or ``"bic"``.
+
+    Returns:
+        DataFrame sorted by the chosen criterion with delta-IC and weights.
+    """
+    formulas: list[str] = []
+    npars: list[int] = []
+    logliks: list[float] = []
+    deviances: list[float] = []
+    aics: list[float] = []
+    bics: list[float] = []
+
+    for m in models:
+        k = _get_n_params_ic(m)
+        loglik = float(m._fit.loglik)
+        n = m._bundle.n
+
+        formulas.append(m.formula)
+        npars.append(k)
+        logliks.append(loglik)
+        deviances.append(-2.0 * loglik)
+        aics.append(compute_aic(loglik, k))
+        bics.append(compute_bic(loglik, k, n))
+
+    # Select criterion and schema
+    if criterion == "aic":
+        ic_values = aics
+        delta_col = Col.DELTA_AIC
+        schema = ComparisonAic
+    else:
+        ic_values = bics
+        delta_col = Col.DELTA_BIC
+        schema = ComparisonBic
+
+    # Sort all lists by IC value (ascending = best first)
+    order = sorted(range(len(models)), key=lambda i: ic_values[i])
+    formulas = [formulas[i] for i in order]
+    npars = [npars[i] for i in order]
+    logliks = [logliks[i] for i in order]
+    deviances = [deviances[i] for i in order]
+    aics = [aics[i] for i in order]
+    bics = [bics[i] for i in order]
+    ic_values = [ic_values[i] for i in order]
+
+    # Delta-IC: difference from best model
+    ic_min = ic_values[0]
+    deltas = [v - ic_min for v in ic_values]
+
+    # Akaike/Schwarz weights: exp(-0.5 * delta) / sum(exp(-0.5 * delta))
+    raw_weights = [math.exp(-0.5 * d) for d in deltas]
+    weight_sum = sum(raw_weights)
+    weights = [w / weight_sum for w in raw_weights]
+
+    return pl.DataFrame(
+        {
+            Col.MODEL: formulas,
+            Col.NPAR: npars,
+            Col.LOGLIK: logliks,
+            Col.DEVIANCE: deviances,
+            Col.AIC_R: aics,
+            Col.BIC_R: bics,
+            delta_col: deltas,
+            Col.WEIGHT: weights,
+        },
+        schema=schema,
+    )

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/lrt.py

@@ -4,7 +4,7 @@ from typing import Any
 
 import polars as pl
 
-from bossanova.internal.operations.compare.compare import compare
+from bossanova.internal.compare.compare import compare
 
 __all__ = ["lrt"]
 

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/lrt_compare.py

@@ -16,7 +16,7 @@ from bossanova.internal.containers.schemas import (
 from bossanova.internal.maths.config import is_singular
 from bossanova.internal.maths.inference import compute_aic as compute_aic
 from bossanova.internal.maths.inference import compute_bic as _compute_bic
-from bossanova.internal.operations.compare.helpers import check_nested, get_model_type
+from bossanova.internal.compare.helpers import check_nested, get_model_type
 
 __all__ = [
     "compare_lrt",

{bossanova-0.1.0.dev17/bossanova/internal/operations → bossanova-0.1.0.dev19/bossanova/internal}/compare/refit.py

@@ -6,7 +6,7 @@ estimation when the original uses REML, enabling valid likelihood ratio tests.
 
 from typing import Any
 
-from bossanova.internal.operations.compare.helpers import get_model_type
+from bossanova.internal.compare.helpers import get_model_type
 
 __all__ = [
     "refit_with_ml",

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/internal/containers/builders/dataframes.py

@@ -61,7 +61,7 @@ def build_params_dataframe(
     Column set varies by inference method:
 
     - **asymp**: all inference columns (p_value last).
-    - **boot**: no p_value; df = n_resamples.
+    - **boot**: all inference columns; df = n_resamples.
     - **perm**: no CIs; df = n_valid_resamples.
     - **cv**: PRE columns only.
     - **None**: term + estimate only.
@@ -96,6 +96,7 @@ def build_params_dataframe(
         data[Col.CI_UPPER] = params_inference.ci_upper.tolist()
         data[Col.STATISTIC] = params_inference.statistic.tolist()
         data[Col.DF] = params_inference.df.tolist()
+        data[Col.P_VALUE] = params_inference.p_value.tolist()
         return pl.DataFrame(data, schema=ParamsBoot)
 
     if method == "perm":

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/internal/containers/builders/results.py

@@ -28,7 +28,7 @@ _INFERENCE_COLS: tuple[str, ...] = (
 )
 
 # Columns excluded per inference method.
-_BOOT_EXCLUDE: frozenset[str] = frozenset({Col.P_VALUE})
+_BOOT_EXCLUDE: frozenset[str] = frozenset()
 _PERM_EXCLUDE: frozenset[str] = frozenset({Col.CI_LOWER, Col.CI_UPPER})
 
 
@@ -43,7 +43,6 @@ def append_inference_columns(
     column that is not None on *state*. Columns are added in canonical
     order: se, ci_lower, ci_upper, statistic, df, p_value.
 
-    When *method* is ``"boot"``, the ``p_value`` column is excluded.
     When *method* is ``"perm"``, the ``ci_lower`` and ``ci_upper``
     columns are excluded.
 

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/internal/containers/builders/specs.py

@@ -173,7 +173,7 @@ def build_model_spec_from_formula(
     if "~" not in formula:
         raise ValueError(f"Invalid formula: {formula!r}. Formula must contain '~'.")
 
-    from bossanova.internal.operations.formula.parse import extract_formula_structure
+    from bossanova.internal.formula.parse import extract_formula_structure
 
     try:
         structure = extract_formula_structure(formula)
@@ -269,13 +269,20 @@ def build_simulation_spec(
 # =============================================================================
 
 
+_CONTRAST_FUNC_RE = (
+    r"(?:treatment|dummy|sum|deviation|helmert|sequential|poly)\((\w+)(?:,\s*[^)]+)?\)"
+)
+
+
 def parse_formula_simple(formula: str) -> dict[str, Any]:
     """Simple formula parser for simulation defaults.
 
     Parses a model formula to extract variable types for default distributions.
+    Recognizes contrast encoding functions (``treatment(x)``, ``sum(x)``, etc.)
+    as categorical markers.
 
     Args:
-        formula: Model formula (e.g., "y ~ x + factor(group) + (1|subject)").
+        formula: Model formula (e.g., ``"y ~ x + treatment(group) + (1|subject)"``).
 
     Returns:
         Dictionary with keys: response, continuous, factors, re_groups.
@@ -283,6 +290,8 @@ def parse_formula_simple(formula: str) -> dict[str, Any]:
     Examples:
         >>> parse_formula_simple("y ~ x + z")
         {'response': 'y', 'continuous': ['x', 'z'], 'factors': [], 're_groups': []}
+        >>> parse_formula_simple("y ~ treatment(group) + x")
+        {'response': 'y', 'continuous': ['x'], 'factors': ['group'], 're_groups': []}
     """
     if "~" not in formula:
         msg = f"Invalid formula: missing '~'. Got: {formula}"
@@ -297,10 +306,10 @@ def parse_formula_simple(formula: str) -> dict[str, Any]:
         msg = f"Invalid formula: empty response variable. Got: {formula}"
         raise ValueError(msg)
 
-    factors = re.findall(r"factor\((\w+)\)", rhs)
+    factors = re.findall(_CONTRAST_FUNC_RE, rhs)
     re_groups = re.findall(r"\([^)]+\|(\w+)\)", rhs)
 
-    cleaned = re.sub(r"factor\(\w+\)", "", rhs)
+    cleaned = re.sub(_CONTRAST_FUNC_RE, "", rhs)
     cleaned = re.sub(r"\([^)]+\|\w+\)", "", cleaned)
 
     all_terms = re.findall(r"\b([a-zA-Z_]\w*)\b", cleaned)

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/internal/containers/schemas.py

@@ -231,6 +231,7 @@ ParamsBoot = Schema(
         Col.CI_UPPER: Float64,
         Col.STATISTIC: Float64,
         Col.DF: Float64,
+        Col.P_VALUE: Float64,
     }
 )
 
@@ -528,7 +529,7 @@ VaryingCorrSchema = Schema(
 # compare() Schemas (rows = models)
 # =============================================================================
 
-# Currently unused — retained as reference schema for AIC-based comparison.
+# AIC-based model comparison (used by compare(method='aic')).
 ComparisonAic = Schema(
     {
         Col.MODEL: String,
@@ -542,7 +543,7 @@ ComparisonAic = Schema(
     }
 )
 
-# Currently unused — retained as reference schema for BIC-based comparison.
+# BIC-based model comparison (used by compare(method='bic')).
 ComparisonBic = Schema(
     {
         Col.MODEL: String,

{bossanova-0.1.0.dev17 → bossanova-0.1.0.dev19}/bossanova/internal/containers/structs/data.py

@@ -171,7 +171,7 @@ class DataBundle:
     X: NDArray[np.floating] = field(validator=is_ndarray)
     y: NDArray[np.floating] = field(validator=is_ndarray)
     X_names: tuple[str, ...] = field(converter=to_tuple)
-    y_name: str
+    y_name: str = field(validator=validators.instance_of(str))
 
     valid_mask: NDArray[np.bool_] = field(validator=is_ndarray)
     n_total: int = field(validator=validators.instance_of(int))