bossanova 0.1.0.dev10__tar.gz → 0.1.0.dev11__tar.gz

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bossanova
-Version: 0.1.0.dev10
+Version: 0.1.0.dev11
 Summary: Bridging statistical cultures with some jazz
 Author: Eshin Jolly
 License-Expression: MIT

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/containers/structs/data.py

@@ -5,7 +5,7 @@ from __future__ import annotations
 from typing import TYPE_CHECKING
 
 import numpy as np
-from attrs import field, frozen
+from attrs import field, frozen, validators
 
 from bossanova.internal.containers.validators import (
     is_ndarray,
@@ -112,8 +112,8 @@ class RankInfo:
         True
     """
 
-    rank: int
-    p: int
+    rank: int = field(validator=validators.instance_of(int))
+    p: int = field(validator=validators.instance_of(int))
     kept_indices: NDArray[np.intp] = field(validator=is_ndarray)
     dropped_indices: tuple[int, ...] = field(converter=tuple)
     dropped_names: tuple[str, ...] = field(converter=tuple)
@@ -174,7 +174,7 @@ class DataBundle:
     y_name: str
 
     valid_mask: NDArray[np.bool_] = field(validator=is_ndarray)
-    n_total: int
+    n_total: int = field(validator=validators.instance_of(int))
 
     # Optional fields
     Z: sp.csc_matrix | None = field(default=None, validator=is_optional_sparse_csc)

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/containers/structs/display.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from attrs import field, frozen
+from attrs import field, frozen, validators
 
 __all__ = [
     "MathDisplay",
@@ -24,12 +24,12 @@ class TermInfo:
         explanation: Human-readable explanation string.
     """
 
-    name: str
-    term_type: str
-    base_var: str
-    symbol: str
-    latex: str
-    explanation: str
+    name: str = field(validator=validators.instance_of(str))
+    term_type: str = field(validator=validators.instance_of(str))
+    base_var: str = field(validator=validators.instance_of(str))
+    symbol: str = field(validator=validators.instance_of(str))
+    latex: str = field(validator=validators.instance_of(str))
+    explanation: str = field(validator=validators.instance_of(str))
 
 
 @frozen
@@ -50,9 +50,9 @@ class MathDisplay:
         >>> display              # renders in Jupyter
     """
 
-    equation: str
+    equation: str = field(validator=validators.instance_of(str))
     explanations: tuple[str, ...] = field(factory=tuple)
-    model_info: str = ""
+    model_info: str = field(default="", validator=validators.instance_of(str))
 
     def _repr_latex_(self) -> str:
         """LaTeX representation for Jupyter rendering."""

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/containers/structs/explore.py

@@ -1,6 +1,6 @@
 """Parsing result containers for explore formulas."""
 
-from attrs import field, frozen
+from attrs import field, frozen, validators
 
 __all__ = [
     "Condition",
@@ -23,7 +23,7 @@ class Condition:
         at_quantile: Number of quantile values to use.
     """
 
-    var: str
+    var: str = field(validator=validators.instance_of(str))
     at_values: tuple | None = field(default=None)
     at_range: int | None = field(default=None)
     at_quantile: int | None = field(default=None)
@@ -47,7 +47,7 @@ class ExploreFormula:
             (e.g., from ``Days[0, 3, 6, 9]`` syntax). None means use all levels.
     """
 
-    focal_var: str
+    focal_var: str = field(validator=validators.instance_of(str))
     contrast_type: str | None = field(default=None)
     contrast_degree: int | None = field(default=None)
     conditions: tuple[Condition, ...] = field(factory=tuple, converter=tuple)

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/containers/structs/formula.py

@@ -4,7 +4,7 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING
 
-from attrs import field, frozen
+from attrs import field, frozen, validators
 
 from bossanova.internal.containers.validators import (
     to_factor_dict,
@@ -53,7 +53,7 @@ class FormulaSpec:
     """
 
     # --- Parsing results (from formula string) ---
-    formula: str
+    formula: str = field(validator=validators.instance_of(str))
     response_var: str | None = field(default=None)
     response_transform: tuple[str, ...] | None = field(default=None)
     has_intercept: bool = field(default=True)

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/containers/structs/specs.py

@@ -79,8 +79,8 @@ class ModelSpec:
     """
 
     # Required fields
-    formula: str
-    response_var: str
+    formula: str = field(validator=validators.instance_of(str))
+    response_var: str = field(validator=validators.instance_of(str))
     fixed_terms: tuple[str, ...] = field(converter=to_tuple)
 
     # Optional fields with defaults and validation

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/containers/structs/state.py

@@ -7,7 +7,7 @@ CVState, SimulationInferenceState, VaryingState, VaryingSpreadState).
 
 from __future__ import annotations
 
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Any
 
 import numpy as np
 from attrs import field, frozen, validators
@@ -15,6 +15,7 @@ from attrs import field, frozen, validators
 from bossanova.internal.containers.validators import (
     is_ndarray,
     is_optional_ndarray,
+    to_tuple,
 )
 
 if TYPE_CHECKING:
@@ -240,9 +241,9 @@ class MeeState:
     grid: "pl.DataFrame" = field(repr=False)
     estimate: np.ndarray = field(validator=is_ndarray)
 
-    explore_formula: str
-    focal_var: str
-    type: str  # "means", "slopes", "contrasts"
+    explore_formula: str = field(validator=validators.instance_of(str))
+    focal_var: str = field(validator=validators.instance_of(str))
+    type: str = field(validator=validators.in_(("means", "slopes", "contrasts")))
     units: str = field(default="link", validator=validators.in_(("link", "data")))
 
     # Design matrix for delta method inference (optional)
@@ -313,7 +314,7 @@ class JointTestState:
     """
 
     # Required fields
-    terms: tuple[str, ...]
+    terms: tuple[str, ...] = field(converter=to_tuple)
     df1: np.ndarray = field(validator=is_ndarray)  # Numerator df per term
     statistic: np.ndarray = field(validator=is_ndarray)  # F or chi2 values
     p_value: np.ndarray = field(validator=is_ndarray)
@@ -545,8 +546,8 @@ class SimulationInferenceState:
             >>> m.sim_inference.power["x"]  # Proportion of sims where p < 0.05
     """
 
-    sim_type: str  # "post_fit" or "power_analysis"
-    n_sims: int
+    sim_type: str = field(validator=validators.in_(("post_fit", "power_analysis")))
+    n_sims: int = field(validator=validators.instance_of(int))
 
     # Post-fit simulation summaries (per observation)
     sim_mean: np.ndarray | None = field(default=None)
@@ -601,9 +602,9 @@ class VaryingState:
 
     # Required fields
     grid: "pl.DataFrame" = field(repr=False)
-    effects: dict[str, np.ndarray]
-    grouping_var: str
-    n_groups: int
+    effects: dict[str, np.ndarray] = field(validator=validators.instance_of(dict))
+    grouping_var: str = field(validator=validators.instance_of(str))
+    n_groups: int = field(validator=validators.instance_of(int))
 
     # Inference (optional, added by .infer())
     # These are dicts: effect_name -> array of interval bounds
@@ -667,8 +668,8 @@ class VaryingSpreadState:
 
     # Required fields
     components: "pl.DataFrame" = field(repr=False)
-    sigma2: float
-    tau2: dict[str, float]
+    sigma2: float = field(validator=validators.instance_of((int, float)))
+    tau2: dict[str, float] = field(validator=validators.instance_of(dict))
 
     # Optional fields
     rho: dict[str, float] = field(factory=dict)  # "effect1_effect2" -> correlation
@@ -727,15 +728,25 @@ class ProfileState:
     """
 
     table: "pl.DataFrame" = field(repr=False)
-    spline_forward: dict = field(repr=False)
-    spline_reverse: dict = field(repr=False)
-    ci_theta: dict[str, tuple[float, float]]
-    ci_sd: dict[str, tuple[float, float]]
-    ci_lower_sd: "NDArray[np.floating]" = field(repr=False)
-    ci_upper_sd: "NDArray[np.floating]" = field(repr=False)
-    conf_level: float
-    dev_opt: float
-    threshold: float = 4.0
+    spline_forward: dict[str, Any] = field(
+        repr=False, validator=validators.instance_of(dict)
+    )
+    spline_reverse: dict[str, Any] = field(
+        repr=False, validator=validators.instance_of(dict)
+    )
+    ci_theta: dict[str, tuple[float, float]] = field(
+        validator=validators.instance_of(dict)
+    )
+    ci_sd: dict[str, tuple[float, float]] = field(
+        validator=validators.instance_of(dict)
+    )
+    ci_lower_sd: NDArray[np.floating] = field(repr=False, validator=is_ndarray)
+    ci_upper_sd: NDArray[np.floating] = field(repr=False, validator=is_ndarray)
+    conf_level: float = field(validator=validators.instance_of((int, float)))
+    dev_opt: float = field(validator=validators.instance_of((int, float)))
+    threshold: float = field(
+        default=4.0, validator=validators.instance_of((int, float))
+    )
 
 
 # =============================================================================

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/maths/design/reference.py

@@ -19,6 +19,8 @@ def build_reference_design_matrix(
     focal_var: str,
     levels: list[str],
     X_means: np.ndarray,
+    *,
+    set_categoricals: dict[str, str] | None = None,
 ) -> np.ndarray:
     """Build design matrix for reference grid points.
 
@@ -38,6 +40,10 @@ def build_reference_design_matrix(
         levels: List of levels for the focal variable, defining row order.
         X_means: Column means of the original design matrix, shape (p,).
             Used for continuous covariate reference values.
+        set_categoricals: Optional dict mapping non-focal categorical variable
+            names to specific levels to pin them at (instead of marginalizing
+            at X_means). E.g. ``{"Ethnicity": "Asian"}`` sets the Ethnicity
+            dummies to indicator values for "Asian".
 
     Returns:
         Reference design matrix X_ref, shape (n_levels, p).
@@ -64,7 +70,9 @@ def build_reference_design_matrix(
     X_ref = np.zeros((n_levels, p), dtype=np.float64)
 
     for i, level in enumerate(levels):
-        X_ref[i] = build_reference_row(X_names, focal_var, level, X_means)
+        X_ref[i] = build_reference_row(
+            X_names, focal_var, level, X_means, set_categoricals=set_categoricals
+        )
 
     return X_ref
 
@@ -74,6 +82,8 @@ def build_reference_row(
     focal_var: str,
     focal_level: str,
     X_means: np.ndarray,
+    *,
+    set_categoricals: dict[str, str] | None = None,
 ) -> np.ndarray:
     """Build a single row of the reference design matrix.
 
@@ -90,6 +100,11 @@ def build_reference_row(
         focal_var: Name of the focal categorical variable.
         focal_level: Level value to set for the focal variable.
         X_means: Column means for continuous covariate reference values.
+        set_categoricals: Optional dict mapping non-focal categorical variable
+            names to specific levels for indicator encoding. When a non-focal
+            categorical's ``base_term`` matches a key, the dummy is set to
+            ``1.0`` if the level matches, ``0.0`` otherwise (instead of using
+            the column mean for marginalization).
 
     Returns:
         Reference row, shape (p,).
@@ -110,10 +125,13 @@ def build_reference_row(
                 X_means,
                 focal_var=focal_var,
                 focal_level=focal_level,
+                set_categoricals=set_categoricals,
             )
         elif info.column_type == "categorical":
             if info.base_term == focal_var:
                 row[j] = 1.0 if info.level == focal_level else 0.0
+            elif set_categoricals and info.base_term in set_categoricals:
+                row[j] = 1.0 if info.level == set_categoricals[info.base_term] else 0.0
             else:
                 row[j] = X_means[j]
         else:
@@ -243,12 +261,13 @@ def _resolve_interaction_value(
     *,
     focal_level: str | None = None,
     focal_value: float | None = None,
+    set_categoricals: dict[str, str] | None = None,
 ) -> float:
     """Compute reference value for an interaction column.
 
-    If the interaction involves the focal variable, computes the product
-    of component values (focal dummy/value times non-focal means). Otherwise,
-    returns the empirical column mean for marginalization.
+    If the interaction involves the focal variable or a pinned categorical,
+    computes the product of component values. Otherwise, returns the
+    empirical column mean for marginalization.
 
     Args:
         col_name: Interaction column name (e.g., ``"Income:Student[Yes]"``).
@@ -259,22 +278,28 @@ def _resolve_interaction_value(
             ``focal_value``).
         focal_value: Value for continuous focal (mutually exclusive with
             ``focal_level``).
+        set_categoricals: Dict mapping non-focal categorical names to
+            pinned levels. When an interaction part's base_term matches,
+            the indicator value is used instead of the column mean.
 
     Returns:
         Computed reference value for the interaction column.
     """
     parts = col_name.split(":")
 
-    # Check if any part of the interaction involves the focal variable
+    # Check if any part involves the focal variable or a pinned categorical
     involves_focal = any(
         parse_design_column_name(p).base_term == focal_var for p in parts
     )
+    involves_pinned = set_categoricals is not None and any(
+        parse_design_column_name(p).base_term in set_categoricals for p in parts
+    )
 
-    if not involves_focal:
-        # Non-focal interaction: use empirical column mean (marginalize)
+    if not involves_focal and not involves_pinned:
+        # Non-focal, non-pinned interaction: use empirical column mean
         return float(X_means[X_names_list.index(col_name)])
 
-    # Focal interaction: compute product of component values
+    # Decompose and compute product of component values
     product = 1.0
     for part in parts:
         pinfo = parse_design_column_name(part)
@@ -286,6 +311,13 @@ def _resolve_interaction_value(
                 product *= focal_value
             elif part in X_names_list:
                 product *= float(X_means[X_names_list.index(part)])
+        elif (
+            set_categoricals
+            and pinfo.column_type == "categorical"
+            and pinfo.base_term in set_categoricals
+        ):
+            # Pinned categorical component: use indicator
+            product *= 1.0 if pinfo.level == set_categoricals[pinfo.base_term] else 0.0
         elif part in X_names_list:
             # Non-focal component: use its column mean
             product *= float(X_means[X_names_list.index(part)])

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/operations/infer/profile.py

@@ -118,8 +118,10 @@ def compute_profile_inference(
     from bossanova.internal.containers.structs.state import ProfileState
     from bossanova.internal.maths.inference.profile import profile_likelihood
     from bossanova.internal.maths.solvers.lambda_builder import build_lambda_template
-    from bossanova.internal.maths.solvers.lmm_deviance import lmm_deviance_sparse
-    from bossanova.internal.maths.solvers.pls import compute_pls_invariants
+    from bossanova.internal.maths.solvers.lmer import (
+        compute_pls_invariants,
+        lmm_deviance_sparse,
+    )
     from bossanova.internal.operations.varying import per_factor_re_info
 
     re_meta = bundle.re_metadata

{bossanova-0.1.0.dev10 → bossanova-0.1.0.dev11}/bossanova/internal/operations/marginal/__init__.py

@@ -36,8 +36,15 @@ from bossanova.internal.operations.marginal.slopes import (
 from bossanova.internal.operations.marginal.compute import (
     dispatch_marginal_computation,
 )
+from bossanova.internal.operations.marginal.conditions import (
+    ResolvedConditions,
+    combine_resolved,
+    merge_at_kwarg,
+    resolve_conditions,
+)
 from bossanova.internal.operations.marginal.contrasts import (
     apply_contrasts,
+    apply_contrasts_grouped,
     compute_contrasts,
     pairwise_contrasts,
     poly_contrasts,
@@ -56,8 +63,11 @@ __all__ = [
     "Condition",
     "ExploreFormula",
     "ExploreFormulaError",
+    "ResolvedConditions",
     "apply_contrasts",
+    "apply_contrasts_grouped",
     "build_reference_grid",
+    "combine_resolved",
     "compute_conditional_emm",
     "compute_conditional_slopes",
     "compute_contrasts",
@@ -69,8 +79,10 @@ __all__ = [
     "compute_slopes",
     "compute_slopes_finite_diff",
     "dispatch_marginal_computation",
+    "merge_at_kwarg",
     "pairwise_contrasts",
     "parse_explore_formula",
     "poly_contrasts",
+    "resolve_conditions",
     "sequential_contrasts",
 ]