process-improve 2.2.0__tar.gz → 2.2.2__tar.gz

{process_improve-2.2.0 → process_improve-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-improve
-Version: 2.2.0
+Version: 2.2.2
 Summary: Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.
 Keywords: Designed Experiments,Design of Experiments,DoE,Optimal Design,Response Surface,Latent Variables,PCA,PLS,Multivariate Data Analysis,Chemometrics,Process Monitoring,Batch data analysis
 Author: Kevin Dunn

{process_improve-2.2.0 → process_improve-2.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "process-improve"
-version = "2.2.0"
+version = "2.2.2"
 description = "Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis."
 readme = "README.md"
 license = "MIT"
@@ -301,3 +301,32 @@ known-third-party = [
     "pytest",
     "pandas",
 ]
+
+[tool.mutmut]
+source_paths = ["src"]
+only_mutate = [
+    "src/process_improve/multivariate/_limits.py",
+    "src/process_improve/monitoring/metrics.py",
+    "src/process_improve/monitoring/evop.py",
+    "src/process_improve/monitoring/control_charts.py",
+]
+pytest_add_cli_args = [
+    "-o",
+    "addopts=",
+    "-p",
+    "no:cacheprovider",
+]
+pytest_add_cli_args_test_selection = [
+    "tests/test_multivariate_limits.py",
+    "tests/test_multivariate.py",
+    "tests/test_audit_regressions_multivariate.py",
+    "tests/test_multiblock_validation.py",
+    "tests/test_multivariate_introspection.py",
+    "tests/test_monitoring.py",
+    "tests/test_monitoring_helpers.py",
+    "tests/test_audit_regressions_univariate_monitoring.py",
+    "tests/test_evop.py",
+    "tests/test_control_chart_cusum.py",
+    "tests/test_control_chart_ewma.py",
+    "tests/test_control_chart_hw_golden.py",
+]

{process_improve-2.2.0 → process_improve-2.2.2}/pyproject.toml.orig

@@ -1,6 +1,6 @@
 [project]
 name = "process-improve"
-version = "2.2.0"
+version = "2.2.2"
 description = 'Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.'
 readme = "README.md"
 license = "MIT"
@@ -449,3 +449,31 @@ docstring-quotes = "double"
 
 [tool.ruff.lint.isort]
 known-third-party=["pytest", "pandas"]
+
+# Mutation testing: see "Mutation testing" in CONTRIBUTING.md. Modules join `only_mutate` one at a
+# time, each with no survivor, starting with those whose numbers users act on; the tests listed
+# are those that reach them.
+[tool.mutmut]
+source_paths = ["src"]
+only_mutate = [
+    "src/process_improve/multivariate/_limits.py",
+    "src/process_improve/monitoring/metrics.py",
+    "src/process_improve/monitoring/evop.py",
+    "src/process_improve/monitoring/control_charts.py",
+]
+# The runner drops pytest.ini's addopts: no xdist workers and no coverage inside each mutant run.
+pytest_add_cli_args = ["-o", "addopts=", "-p", "no:cacheprovider"]
+pytest_add_cli_args_test_selection = [
+    "tests/test_multivariate_limits.py",
+    "tests/test_multivariate.py",
+    "tests/test_audit_regressions_multivariate.py",
+    "tests/test_multiblock_validation.py",
+    "tests/test_multivariate_introspection.py",
+    "tests/test_monitoring.py",
+    "tests/test_monitoring_helpers.py",
+    "tests/test_audit_regressions_univariate_monitoring.py",
+    "tests/test_evop.py",
+    "tests/test_control_chart_cusum.py",
+    "tests/test_control_chart_ewma.py",
+    "tests/test_control_chart_hw_golden.py",
+]

process_improve-2.2.2/src/process_improve/_tool_registry.py

@@ -0,0 +1,205 @@
+"""(c) Kevin Dunn, 2010-2026. MIT License.
+
+The ``@tool_spec`` decorator, the registry it fills, and ``clean``.
+
+These are the parts of :mod:`process_improve.tool_spec` that every ``tools.py``
+module imports. They live apart from tool discovery, which names every
+``tools.py`` module, so that a tool module depends on this file alone and not,
+through discovery, on every other tool module. ``tool_spec.py`` re-exports all
+of it, and callers import it from there.
+"""
+
+from __future__ import annotations
+
+import math
+from collections.abc import Callable
+from typing import Any
+
+import numpy as np
+from pydantic import BaseModel
+
+# ---------------------------------------------------------------------------
+# Registry
+# ---------------------------------------------------------------------------
+
+#: Maps tool name -> decorated callable.  Populated by ``@tool_spec``.
+_TOOL_REGISTRY: dict[str, Callable[..., Any]] = {}
+
+
+# ---------------------------------------------------------------------------
+# RNG metadata validation
+# ---------------------------------------------------------------------------
+
+
+def _validate_rng_metadata(name: str, rng: dict[str, Any]) -> None:
+    """Reject ``rng`` payloads that don't match the published contract.
+
+    The contract is intentionally narrow so downstream consumers (the
+    factorial reproducible-export service) can introspect specs without
+    defensive type-checking. See ``CLAUDE.md`` for the full schema.
+    """
+    if not isinstance(rng, dict):
+        raise TypeError(f"@tool_spec(name={name!r}): 'rng' must be a dict, got {type(rng).__name__}.")
+    if "uses_rng" not in rng or not isinstance(rng["uses_rng"], bool):
+        raise ValueError(f"@tool_spec(name={name!r}): 'rng' must have a boolean 'uses_rng' key.")
+    allowed_keys = {"uses_rng", "seed_param", "default_seed", "note"}
+    extra = set(rng) - allowed_keys
+    if extra:
+        raise ValueError(
+            f"@tool_spec(name={name!r}): unknown keys in 'rng': {sorted(extra)}. Allowed: {sorted(allowed_keys)}."
+        )
+    if not rng["uses_rng"]:
+        # Deterministic tools shouldn't carry a seed_param / default_seed.
+        if rng.get("seed_param") is not None or rng.get("default_seed") is not None:
+            raise ValueError(
+                f"@tool_spec(name={name!r}): 'seed_param' / 'default_seed' must be omitted when uses_rng is False."
+            )
+        return
+    seed_param = rng.get("seed_param")
+    if seed_param is not None and not isinstance(seed_param, str):
+        raise TypeError(
+            f"@tool_spec(name={name!r}): 'seed_param' must be a string or None, got {type(seed_param).__name__}."
+        )
+    default_seed = rng.get("default_seed")
+    if default_seed is not None and not isinstance(default_seed, int):
+        raise TypeError(
+            f"@tool_spec(name={name!r}): 'default_seed' must be an int or None, got {type(default_seed).__name__}."
+        )
+    if seed_param is None and default_seed is not None:
+        raise ValueError(f"@tool_spec(name={name!r}): 'default_seed' requires a 'seed_param' name.")
+
+
+# ---------------------------------------------------------------------------
+# Decorator
+# ---------------------------------------------------------------------------
+
+
+def tool_spec(  # noqa: PLR0913
+    name: str,
+    description: str,
+    *,
+    input_model: type[BaseModel],
+    examples: str = "",
+    category: str = "",
+    rng: dict[str, Any] | None = None,
+) -> Callable[[Callable[..., Any]], Callable[..., Any]]:
+    """Mark a function as an agent-callable tool.
+
+    Parameters
+    ----------
+    name:
+        Unique tool name exposed to the LLM (snake_case).
+    description:
+        Natural-language description of what the tool does and when to use it.
+    input_model:
+        A :class:`pydantic.BaseModel` subclass describing the tool's
+        input. The model is the single source of truth for both the
+        function's Python signature and the MCP JSON Schema (derived
+        via :meth:`BaseModel.model_json_schema`). Every input model
+        **must** set ``model_config = ConfigDict(extra="forbid")`` so
+        unknown keys are rejected (closes the SEC-15
+        kwarg-injection vector at the schema layer).
+
+        The decorated function then receives the parsed model as its
+        single positional argument::
+
+            class FooInput(BaseModel):
+                model_config = ConfigDict(extra="forbid")
+                values: list[float] = Field(..., min_length=2)
+
+            @tool_spec(name="foo", description="...", input_model=FooInput)
+            def foo(spec: FooInput) -> dict:
+                return {"n": len(spec.values)}
+    examples:
+        Optional natural-language -> tool-call mappings appended to
+        ``description`` so the LLM sees worked examples.
+    category:
+        Optional category string (e.g. ``"univariate"``). Used for
+        filtering with :func:`get_tool_specs`.
+    rng:
+        Optional reproducibility metadata; see :func:`_validate_rng_metadata`
+        for the contract.
+
+    Returns
+    -------
+    Callable
+        The original function, with an attached ``_tool_spec`` dict
+        and ``_input_model`` attribute.
+    """
+    if rng is not None:
+        _validate_rng_metadata(name, rng)
+
+    if not (isinstance(input_model, type) and issubclass(input_model, BaseModel)):
+        raise TypeError(
+            f"@tool_spec(name={name!r}): input_model must be a pydantic BaseModel subclass; got {input_model!r}."
+        )
+    extra_policy = input_model.model_config.get("extra")
+    if extra_policy != "forbid":
+        raise ValueError(
+            f"@tool_spec(name={name!r}): input_model {input_model.__name__} "
+            "must set model_config = ConfigDict(extra='forbid') so unknown "
+            "kwargs are rejected (ENG-04 / SEC-15 contract)."
+        )
+
+    def decorator(func: Callable[..., Any]) -> Callable[..., Any]:
+        """Attach the assembled tool spec to ``func`` and return it unchanged."""
+        full_description = description
+        if examples:
+            full_description = f"{description}\n\nExamples\n--------\n{examples}"
+
+        spec: dict[str, Any] = {
+            "name": name,
+            "description": full_description,
+            "input_schema": input_model.model_json_schema(),
+        }
+        if category:
+            spec["category"] = category
+        if rng is not None:
+            spec["rng"] = dict(rng)
+
+        func._tool_spec = spec  # type: ignore[attr-defined]
+        func._input_model = input_model  # type: ignore[attr-defined]
+        _TOOL_REGISTRY[name] = func
+        return func
+
+    return decorator
+
+
+# ---------------------------------------------------------------------------
+# Serialisation helper
+# ---------------------------------------------------------------------------
+
+
+def clean(value: Any) -> Any:  # noqa: PLR0911, ANN401
+    """Recursively convert numpy scalars / arrays to plain Python types.
+
+    All ``tools.py`` modules should call ``clean(result)`` before returning
+    so that every tool output is JSON-serialisable.
+    """
+    if isinstance(value, dict):
+        # Keys need unwrapping too: json.dumps rejects numpy scalar keys (a
+        # dict keyed by np.int64 group labels from a pandas groupby is the
+        # common case), and previously they leaked through untouched. Only
+        # numpy scalars are unwrapped - other key types pass through so
+        # hashability is never at risk.
+        return {(k.item() if isinstance(k, np.generic) else k): clean(v) for k, v in value.items()}
+    if isinstance(value, (list, tuple, set, frozenset)):
+        return [clean(v) for v in value]
+    # np.bool_ subclasses neither np.integer nor Python bool, and json.dumps
+    # rejects it; it must be tested before the numeric branches.
+    if isinstance(value, np.bool_):
+        return bool(value)
+    if isinstance(value, np.integer):
+        return int(value)
+    if isinstance(value, np.floating):
+        v = float(value)
+        return None if math.isnan(v) or math.isinf(v) else v
+    if isinstance(value, float):
+        return None if math.isnan(value) or math.isinf(value) else value
+    if isinstance(value, np.ndarray):
+        return clean(value.tolist())
+    if isinstance(value, np.generic):
+        # Catch-all for the remaining numpy scalar types (datetime64,
+        # complex, str_, ...): unwrap to the closest Python equivalent.
+        return clean(value.item())
+    return value

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/_analyses/glm.py

@@ -88,9 +88,10 @@ def _trials(df: pd.DataFrame, trials: str | float | Sequence[float] | None) -> n
     if trials is None:
         return None
     if isinstance(trials, str):
-        return df[trials].to_numpy(dtype=float)
-    found = np.broadcast_to(np.asarray(trials, dtype=float), (len(df),)).copy()
-    if np.any(found <= 0):
+        found = df[trials].to_numpy(dtype=float)  # a missing count already dropped its run
+    else:
+        found = np.broadcast_to(np.asarray(trials, dtype=float), (len(df),)).copy()
+    if np.any(found <= 0):  # a column too (#1001): a zero reached statsmodels, which divided by it
         raise ValueError("Every run's number of trials must be positive.")
     return found
 

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/_lm.py

@@ -526,8 +526,8 @@ class Model(OLS):
 
         return smry
 
-    def get_parameters(self, drop_intercept: bool = True) -> pd.DataFrame:
-        """Get the parameter values; return them in a Pandas dataframe."""
+    def get_parameters(self, drop_intercept: bool = True) -> pd.Series:
+        """Get the parameter values; return them in a pandas Series indexed by term."""
 
         params = self._OLS.params.copy()
         try:

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/_tools/fit_linear_model.py

@@ -98,10 +98,7 @@ def fit_linear_model(spec: FitLinearModelInput) -> dict[str, Any]:
         model = lm(spec.formula, expt_data)
 
         params = model.get_parameters(drop_intercept=True)
-        if isinstance(params, pd.Series):
-            coefficients = [{"name": str(name), "estimate": float(value)} for name, value in params.items()]
-        else:
-            coefficients = params.to_dict(orient="records")
+        coefficients = [{"name": str(name), "estimate": float(value)} for name, value in params.items()]
 
         r2 = float(model._OLS.rsquared)
 

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/_uniform_sampling.py

@@ -317,14 +317,12 @@ class UniformSampler:
             t_lo = np.maximum(t_lo, np.where(rate < 0, limit, -np.inf).max(axis=1))
         return np.minimum(t_lo, 0.0), np.maximum(t_hi, 0.0)
 
-    def _step(self, x: np.ndarray, rng: np.random.Generator, shape: np.ndarray | None = None) -> np.ndarray:
+    def _step(self, x: np.ndarray, rng: np.random.Generator, shape: np.ndarray) -> np.ndarray:
         """Move every chain once: a random direction, a uniform point on its chord, shrinking on a miss.
 
-        Directions are Gaussian with covariance ``shape @ shape.T`` (isotropic by default).
+        Directions are Gaussian with covariance ``shape @ shape.T`` (see :meth:`_direction_shape`).
         """
-        d = rng.standard_normal(x.shape)
-        if shape is not None:
-            d = d @ shape.T
+        d = rng.standard_normal(x.shape) @ shape.T
         if self.on_simplex:
             d -= d.mean(axis=1, keepdims=True)  # stay on the plane where the proportions sum to 1
         d /= np.linalg.norm(d, axis=1, keepdims=True)

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/analysis.py

@@ -428,8 +428,13 @@ def _missing_cells_text(df: pd.DataFrame, lost: list[str]) -> str:
 
 
 def _drop_incomplete_runs(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
-    """Drop runs with a missing response or factor setting, warning how many went."""
+    """Drop runs with a missing response or factor setting, warning how many went; refuse when none is left."""
     complete = df[columns].notna().all(axis=1)
+    if not complete.any():
+        raise ValueError(
+            f"No run has a value in every one of {', '.join(map(str, columns))}, so there is nothing to analyse: "
+            "each run is missing its response or a factor setting."
+        )
     n_dropped = int((~complete).sum())
     if n_dropped:
         warnings.warn(
@@ -441,6 +446,33 @@ def _drop_incomplete_runs(df: pd.DataFrame, columns: list[str]) -> pd.DataFrame:
     return df
 
 
+def _stand_in(name: str, taken: pd.Index) -> str:
+    """Return a name a formula can hold for the response: ``name_``, else ``name_1``, ``name_2``, ...
+
+    The stand-in never gains a second underscore, which the formula check refuses as dunder access (#1002).
+    """
+    alias, k = f"{name}_", 0
+    while alias in taken:
+        k += 1
+        alias = f"{name}_{k}"
+    return alias
+
+
+def _check_response_scale(response: pd.Series, name: str) -> None:
+    """Refuse a response whose sums of squares cannot be held in double precision (#1005).
+
+    Every test, R-squared and p-value is unchanged when the response is divided by a constant,
+    so the remedy is a change of units; past this size ``n * max(y)**2`` overflows.
+    """
+    largest = float(np.max(np.abs(response.to_numpy(dtype=float))))
+    if largest > np.sqrt(np.finfo(float).max / len(response)):
+        raise ValueError(
+            f"The response {name!r} is too large in its units to analyse: its sums of squares overflow, as its "
+            f"largest value is {largest:.3g}. Divide it by a power of 10 and analyse it again; the tests, "
+            "R-squared and p-values do not change."
+        )
+
+
 def _top_level_terms(rhs: str) -> list[str]:
     """Split a formula's right-hand side at the ``+`` signs outside parentheses."""
     terms, depth, start = [], 0, 0
@@ -1284,11 +1316,8 @@ def analyze_experiment(  # noqa: PLR0913
         # "yield" is the commonest response in chemistry, and a Python keyword, which a
         # formula cannot name; a column named C, I or Q hides patsy's function of that
         # name, so I(x1 ** 2) fails. Fit under a stand-in name and report the real one.
-        alias = f"{response_col}_"
-        while alias in df.columns:
-            alias += "_"
-        df = df.rename(columns={response_col: alias})
-        response_col = alias
+        response_col = _stand_in(response_col, df.columns)
+        df = df.rename(columns={reported_response: response_col})
 
     # Factor columns = everything except the response and the design-bookkeeping
     # columns. A DesignResult carries "RunOrder" (and optionally "Block"); if a
@@ -1324,6 +1353,7 @@ def analyze_experiment(  # noqa: PLR0913
         *([trials_col] if trials_col else []),
     ]
     df = _drop_incomplete_runs(df, used)
+    _check_response_scale(df[response_col], reported_response)
     coding = _resolve_coding(coding, df, factor_cols, model)
 
     categorical = [c for c in factor_cols if not _is_numeric(df[c])]
@@ -1466,21 +1496,54 @@ def _design_rank(df: pd.DataFrame, rhs: str, factor_cols: list[str], model: str)
     design's in floating point when the units are very unequal (pascals beside kelvin)
     or a span is tiny next to its distance from zero. Coding each numeric factor to
     -1/+1 removes both without changing which terms the runs can separate, as long as
-    the coding re-expresses the model. A model that is not hierarchical can span other
-    columns once coded: ``A:B`` without ``B``, or a factor nested in another through the
-    other's 0/1 indicators, ``I1:B + I2:B``, which coded are ``(2*I1 - 1)*B`` and its
-    negative. Its rank is then its own, of its columns as given scaled to unit length,
-    which no choice of units changes. A mixture model's components are proportions and
-    are not coded.
+    the coding re-expresses the model (see :func:`_coding_re_expresses`). A model that is
+    not hierarchical can span other columns once coded: ``A:B`` without ``A`` and ``B``,
+    which coded varies where ``A * B`` is the same in every run, or a factor nested in
+    another through the other's 0/1 indicators, ``I1:B + I2:B``, which coded are
+    ``(2*I1 - 1)*B`` and its negative. Its rank is then its own, of its columns as given
+    scaled to unit length, which no choice of units changes. A mixture model's components
+    are proportions and are not coded.
     """
     coded = np.asarray(_coded_model_matrix(df, rhs, factor_cols, model), dtype=float)
     rank = int(np.linalg.matrix_rank(coded))
-    if model in SCHEFFE_MODELS:
+    if model in SCHEFFE_MODELS or _coding_re_expresses(df, rhs, factor_cols, coded):
         return rank
-    given = _unit_columns(np.asarray(dmatrix(rhs, df, return_type="dataframe"), dtype=float))
-    if int(np.linalg.matrix_rank(np.hstack([_unit_columns(coded), given]))) == rank:
-        return rank  # the columns as given lie in the coded ones' span: coding re-expressed the model
-    return int(np.linalg.matrix_rank(given))
+    return int(np.linalg.matrix_rank(_unit_columns(np.asarray(dmatrix(rhs, df, return_type="dataframe"), dtype=float))))
+
+
+#: The golden ratio, whose multiples give each factor a different second coding (see :func:`_coding_re_expresses`).
+_GOLDEN_RATIO = (1 + 5**0.5) / 2
+
+
+def _coding_re_expresses(df: pd.DataFrame, rhs: str, factor_cols: list[str], coded: np.ndarray) -> bool:
+    """Whether coding the numeric factors re-expresses the model, rather than changing it.
+
+    A hierarchical model spans the same columns whatever each factor's origin and scale:
+    ``(A - a)*(B - b)`` lies in the span of 1, ``A``, ``B`` and ``A:B``. Another model's span
+    moves with them, and the factors' own units are one more origin and scale. Comparing the
+    coded columns with those as given cannot tell the two apart, since it is the columns as
+    given that may have lost rank in floating point. So the model matrix ``coded`` is compared
+    with a second coding instead, as well conditioned as the first: the i-th numeric factor's
+    -1/+1 coding ``x`` becomes ``(1 + g) * (x + g)``, with ``g`` the fractional part of ``i``
+    times the golden ratio. A span that moves keeps to this coding only if the runs line up
+    with it by chance. When the coded columns already span every run, no coding can add to
+    them, the comparison cannot tell, and the model is taken as changed.
+    """
+    rank = int(np.linalg.matrix_rank(coded))
+    if rank == len(coded):
+        # shortcut: a saturated design is then ranked as given, which a span tiny next to its distance from zero can
+        # lower; compare the codings on more points than the runs if such a design is met.
+        return False
+    second = df.copy()
+    numeric = [col for col in factor_cols if _is_numeric(df[col])]
+    for i, col in enumerate(numeric, start=1):
+        g = i * _GOLDEN_RATIO % 1
+        second[col] = (1 + g) * (_code_factor(df[col])[0] + g)
+    moved = _unit_columns(
+        np.asarray(dmatrix(_coded_formula(rhs, second, factor_cols), second, return_type="dataframe"), dtype=float)
+    )
+    both = np.hstack([_unit_columns(coded), moved])
+    return int(np.linalg.matrix_rank(moved)) == rank == int(np.linalg.matrix_rank(both))
 
 
 def _unit_columns(matrix: np.ndarray) -> np.ndarray:

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/designs_mixture_constrained.py

@@ -245,7 +245,9 @@ def extreme_vertices(a_mat: np.ndarray, b_vec: np.ndarray) -> np.ndarray:
     found = []
     combos = itertools.combinations(range(m), q - 1)
     while chunk := list(itertools.islice(combos, _VERTEX_CHUNK)):
-        subsets = np.array(chunk, dtype=int).reshape(-1, q - 1)
+        # The row count is given, not -1: with one component each subset is empty, and numpy
+        # cannot infer a row count from rows of length 0 (#999).
+        subsets = np.array(chunk, dtype=int).reshape(len(chunk), q - 1)
         systems = np.concatenate([a_red[subsets], np.full((len(subsets), 1, q), 1.0 / np.sqrt(q))], axis=1)
         rhs = np.concatenate([b_red[subsets], np.full((len(subsets), 1), 1.0 / np.sqrt(q))], axis=1)
         solvable = np.abs(np.linalg.det(systems)) > 1e-12  # every row has unit length, so this is a relative test

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/designs_response_surface.py

@@ -420,12 +420,7 @@ def _fractional_cube(
     if not asked:
         generators = [f"{factor_names[-1]}={''.join(factor_names[:-1])}"]
     cube, frac_meta = dispatch_fractional_factorial(factors, resolution=resolution, generators=generators)
-    res = frac_meta.get("resolution")
-    if res is not None and res < 3:
-        raise ValueError(
-            f"The fractional cube has resolution {res}: it aliases main effects with each other, so no model of "
-            "them can be fitted. Supply other generators or use cube='full'."
-        )
+    res = frac_meta.get("resolution")  # 3 or more: dispatch_fractional_factorial refuses generators that alias mains
     aliased = _aliased_interactions(cube, factor_names)
     if aliased and not asked:
         raise ValueError(

{process_improve-2.2.0 → process_improve-2.2.2}/src/process_improve/experiments/designs_supersaturated.py

@@ -109,18 +109,16 @@ def _drop_worst_columns(columns: np.ndarray, k: int) -> np.ndarray:
 def _lin_half_fraction(h: np.ndarray, k: int) -> np.ndarray:
     """Best Lin half-fraction of ``h`` with ``k`` columns, over every choice of branching column."""
     order = h.shape[0]
-    best, best_key = None, (np.inf, np.inf, np.inf)
-    for branch in range(1, order):
-        rows = h[:, branch] > 0
+
+    def branched(branch: int) -> np.ndarray:
         others = [c for c in range(1, order) if c != branch]
-        design = _drop_worst_columns(h[rows][:, others], k)
+        return _drop_worst_columns(h[h[:, branch] > 0][:, others], k)
+
+    def key(design: np.ndarray) -> tuple[int, float, float]:
         s = design.T @ design
-        key = (n_fully_aliased(design), e_s2(design), float(np.abs(s[np.triu_indices_from(s, k=1)]).max()))
-        if key < best_key:
-            best, best_key = design, key
-    if best is None:  # unreachable for order >= 4, which always offers a branching column
-        raise RuntimeError("No branching column was available.")
-    return best
+        return n_fully_aliased(design), e_s2(design), float(np.abs(s[np.triu_indices_from(s, k=1)]).max())
+
+    return min((branched(b) for b in range(1, order)), key=key)  # the first branch of the best key, as before
 
 
 def _smallest_unaliased(k: int) -> np.ndarray | None: