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

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

@@ -1,16 +1,15 @@
 Metadata-Version: 2.4
 Name: process-improve
-Version: 2.0.0
+Version: 2.2.0
 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
 Author-email: Kevin Dunn <kgdunn@gmail.com>
 License-Expression: MIT
-Classifier: Development Status :: 4 - Beta
+Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: Science/Research
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
-Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
@@ -40,31 +39,13 @@ Requires-Dist: openpyxl>=3.1.5 ; extra == 'batch'
 Requires-Dist: ruptures>=1.1.9 ; extra == 'batch'
 Requires-Dist: scikit-image>=0.25.2 ; extra == 'batch'
 Requires-Dist: osqp>=1.0 ; extra == 'control'
-Requires-Dist: coverage>=7.13.1 ; extra == 'dev'
-Requires-Dist: hypothesis>=6.100 ; extra == 'dev'
-Requires-Dist: matplotlib-stubs>=0.3.11 ; extra == 'dev'
-Requires-Dist: mypy>=1.19.1,<2.5 ; extra == 'dev'
-Requires-Dist: pandas-stubs>=2.3.3.260113 ; extra == 'dev'
-Requires-Dist: plotly-stubs>=0.0.6 ; extra == 'dev'
-Requires-Dist: pre-commit>=4.5.1 ; extra == 'dev'
-Requires-Dist: pytest>=9.0.2 ; extra == 'dev'
-Requires-Dist: pytest-benchmark>=4.0.0 ; extra == 'dev'
-Requires-Dist: pytest-cov>=7.0.0 ; extra == 'dev'
-Requires-Dist: pytest-xdist>=3.8.0 ; extra == 'dev'
-Requires-Dist: pydata-sphinx-theme>=0.16.1 ; extra == 'dev'
-Requires-Dist: ruff>=0.11.0,<0.17 ; extra == 'dev'
-Requires-Dist: sphinx>=8.1.3 ; extra == 'dev'
-Requires-Dist: nbsphinx>=0.9.5 ; extra == 'dev'
-Requires-Dist: ipykernel>=6.29 ; extra == 'dev'
-Requires-Dist: tqdm-stubs>=0.2.1 ; extra == 'dev'
-Requires-Dist: watchdog>=6.0.0 ; extra == 'dev'
 Requires-Dist: numba>=0.63.1 ; extra == 'fast'
 Requires-Dist: mcp>=2.0 ; extra == 'mcp'
 Requires-Dist: matplotlib>=3.10.8 ; extra == 'plotting'
 Requires-Dist: plotly>=6.5.2 ; extra == 'plotting'
 Requires-Dist: ridgeplot>=0.5.0 ; extra == 'plotting'
 Requires-Dist: seaborn>=0.13.2 ; extra == 'plotting'
-Requires-Python: >=3.10
+Requires-Python: >=3.11
 Project-URL: Homepage, https://github.com/kgdunn/process-improve
 Project-URL: Documentation, https://kgdunn.github.io/process-improve/
 Project-URL: Try it in your browser, https://kgdunn.github.io/process-improve/app/
@@ -75,7 +56,6 @@ Project-URL: Changelog, https://github.com/kgdunn/process-improve/blob/main/CHAN
 Provides-Extra: all
 Provides-Extra: batch
 Provides-Extra: control
-Provides-Extra: dev
 Provides-Extra: fast
 Provides-Extra: mcp
 Provides-Extra: plotting
@@ -97,7 +77,7 @@ variable moved, and how sure am I?*
 [![Python versions](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fkgdunn%2Fprocess-improve%2Fmain%2Fpyproject.toml&label=python)](https://pypi.org/project/process-improve/)
 [![Downloads](https://static.pepy.tech/badge/process-improve)](https://pepy.tech/project/process-improve)
 [![Downloads per month](https://static.pepy.tech/badge/process-improve/month)](https://pepy.tech/project/process-improve)
-[![CI](https://github.com/kgdunn/process-improve/actions/workflows/run-tests.yml/badge.svg?branch=main&event=push)](https://github.com/kgdunn/process-improve/actions/workflows/run-tests.yml?query=branch%3Amain)
+[![CI](https://github.com/kgdunn/process-improve/actions/workflows/main-status.yml/badge.svg)](https://github.com/kgdunn/process-improve/actions/workflows/run-tests.yml?query=branch%3Amain)
 [![codecov](https://codecov.io/gh/kgdunn/process-improve/branch/main/graph/badge.svg)](https://codecov.io/gh/kgdunn/process-improve)
 [![Docs](https://img.shields.io/badge/docs-kgdunn.github.io-blue.svg)](https://kgdunn.github.io/process-improve/)
 [![License](https://img.shields.io/pypi/l/process-improve.svg)](https://github.com/kgdunn/process-improve/blob/main/LICENSE)
@@ -353,7 +333,7 @@ pip install 'process-improve[fast]'            # adds numba (JIT speedups for ba
 pip install 'process-improve[all]'             # everything above
 ```
 
-Requires Python 3.10 or newer. The core install pulls in `numpy`, `pandas`, `scipy`,
+Requires Python 3.11 or newer. The core install pulls in `numpy`, `pandas`, `scipy`,
 `scikit-learn`, `statsmodels`, `patsy`, `pydantic`, `pyyaml`, `threadpoolctl` and `tqdm`.
 Heavier optional surfaces (plotting, Taguchi arrays, batch IO, batch control, the MCP server, numba JIT)
 live in extras, so a caller who only needs, say, `detect_multivariate_outliers` does not have
@@ -399,6 +379,12 @@ specific version.
 
 MIT: see [LICENSE](https://github.com/kgdunn/process-improve/blob/main/LICENSE) for details.
 
+## Trademarks
+
+OMARS® is a registered trademark of KU Leuven Research & Development. process-improve uses the
+name only for the class of designs defined by Núñez Ares and Goos (2020), and is not affiliated
+with, or endorsed by, KU Leuven, Minitab or Effex.
+
 ## Contributing
 
 Bug reports, feature requests and pull requests are welcome. See

{process_improve-2.0.0 → process_improve-2.2.0}/README.md

@@ -14,7 +14,7 @@ variable moved, and how sure am I?*
 [![Python versions](https://img.shields.io/python/required-version-toml?tomlFilePath=https%3A%2F%2Fraw.githubusercontent.com%2Fkgdunn%2Fprocess-improve%2Fmain%2Fpyproject.toml&label=python)](https://pypi.org/project/process-improve/)
 [![Downloads](https://static.pepy.tech/badge/process-improve)](https://pepy.tech/project/process-improve)
 [![Downloads per month](https://static.pepy.tech/badge/process-improve/month)](https://pepy.tech/project/process-improve)
-[![CI](https://github.com/kgdunn/process-improve/actions/workflows/run-tests.yml/badge.svg?branch=main&event=push)](https://github.com/kgdunn/process-improve/actions/workflows/run-tests.yml?query=branch%3Amain)
+[![CI](https://github.com/kgdunn/process-improve/actions/workflows/main-status.yml/badge.svg)](https://github.com/kgdunn/process-improve/actions/workflows/run-tests.yml?query=branch%3Amain)
 [![codecov](https://codecov.io/gh/kgdunn/process-improve/branch/main/graph/badge.svg)](https://codecov.io/gh/kgdunn/process-improve)
 [![Docs](https://img.shields.io/badge/docs-kgdunn.github.io-blue.svg)](https://kgdunn.github.io/process-improve/)
 [![License](https://img.shields.io/pypi/l/process-improve.svg)](https://github.com/kgdunn/process-improve/blob/main/LICENSE)
@@ -270,7 +270,7 @@ pip install 'process-improve[fast]'            # adds numba (JIT speedups for ba
 pip install 'process-improve[all]'             # everything above
 ```
 
-Requires Python 3.10 or newer. The core install pulls in `numpy`, `pandas`, `scipy`,
+Requires Python 3.11 or newer. The core install pulls in `numpy`, `pandas`, `scipy`,
 `scikit-learn`, `statsmodels`, `patsy`, `pydantic`, `pyyaml`, `threadpoolctl` and `tqdm`.
 Heavier optional surfaces (plotting, Taguchi arrays, batch IO, batch control, the MCP server, numba JIT)
 live in extras, so a caller who only needs, say, `detect_multivariate_outliers` does not have
@@ -316,6 +316,12 @@ specific version.
 
 MIT: see [LICENSE](https://github.com/kgdunn/process-improve/blob/main/LICENSE) for details.
 
+## Trademarks
+
+OMARS® is a registered trademark of KU Leuven Research & Development. process-improve uses the
+name only for the class of designs defined by Núñez Ares and Goos (2020), and is not affiliated
+with, or endorsed by, KU Leuven, Minitab or Effex.
+
 ## Contributing
 
 Bug reports, feature requests and pull requests are welcome. See

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

@@ -1,10 +1,10 @@
 [project]
 name = "process-improve"
-version = "2.0.0"
+version = "2.2.0"
 description = "Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis."
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 keywords = [
     "Designed Experiments",
     "Design of Experiments",
@@ -20,11 +20,10 @@ keywords = [
     "Batch data analysis",
 ]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -75,26 +74,6 @@ all = [
     "scikit-image>=0.25.2",
     "seaborn>=0.13.2",
 ]
-dev = [
-    "coverage>=7.13.1",
-    "hypothesis>=6.100",
-    "matplotlib-stubs>=0.3.11",
-    "mypy>=1.19.1,<2.5",
-    "pandas-stubs>=2.3.3.260113",
-    "plotly-stubs>=0.0.6",
-    "pre-commit>=4.5.1",
-    "pytest>=9.0.2",
-    "pytest-benchmark>=4.0.0",
-    "pytest-cov>=7.0.0",
-    "pytest-xdist>=3.8.0",
-    "pydata-sphinx-theme>=0.16.1",
-    "ruff>=0.11.0,<0.17",
-    "sphinx>=8.1.3",
-    "nbsphinx>=0.9.5",
-    "ipykernel>=6.29",
-    "tqdm-stubs>=0.2.1",
-    "watchdog>=6.0.0",
-]
 
 [project.scripts]
 process-improve-mcp = "process_improve.mcp_server:main"
@@ -168,6 +147,7 @@ select = ["ALL"]
 ignore = [
     "CPY001",
     "C408",
+    "UP042",
     "ARG001",
     "ANN002",
     "ANN003",

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

@@ -1,17 +1,16 @@
 [project]
 name = "process-improve"
-version = "2.0.0"
+version = "2.2.0"
 description = 'Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.'
 readme = "README.md"
 license = "MIT"
-requires-python = ">=3.10"
+requires-python = ">=3.11"
 keywords = ["Designed Experiments", "Design of Experiments", "DoE", "Optimal Design", "Response Surface", "Latent Variables", "PCA", "PLS", "Multivariate Data Analysis", "Chemometrics", "Process Monitoring", "Batch data analysis"]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Science/Research",
     "Operating System :: OS Independent",
     "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
     "Programming Language :: Python :: 3.11",
     "Programming Language :: Python :: 3.12",
     "Programming Language :: Python :: 3.13",
@@ -28,17 +27,18 @@ dependencies = [
     # MCP server, JIT speedups) live in extras; install
     # ``process-improve[all]`` to reproduce the pre-1.24.11 closure.
     "numpy>=2.2.6",
-    # Both pandas majors are supported. pandas 3 needs Python 3.11, so CI's
-    # Python 3.10 jobs test pandas 2.3 and the newer Pythons test pandas 3.
+    # Both pandas majors are supported. CI's Python 3.11 jobs install the lowest
+    # version each dependency allows, so they test pandas 2.3; the newer Pythons
+    # test pandas 3.
     "pandas>=2.3.3",
     "patsy>=1.0.2",
     "pydantic>=2.12.5",
     "pyyaml>=6.0",
     "scikit-learn>=1.7.2",
     # Declared directly because generate_omars solves its ILP with
-    # scipy.optimize.milp (HiGHS). 1.15 is the oldest release CI runs (Python
-    # 3.10 resolves 1.15.3); older releases bundle HiGHS 1.2, which reports a
-    # node-limited stop differently and is not tested here.
+    # scipy.optimize.milp (HiGHS). 1.15 is the oldest release CI runs (the
+    # Python 3.11 jobs resolve 1.15.0); older releases bundle HiGHS 1.2, which
+    # reports a node-limited stop differently and is not tested here.
     "scipy>=1.15",
     "statsmodels>=0.14.6",
     # Already required by scikit-learn; declared because the REML fits of the
@@ -108,27 +108,6 @@ all = [
     "seaborn>=0.13.2",
 ]
 
-dev = [
-    "coverage>=7.13.1",
-    "hypothesis>=6.100",
-    "matplotlib-stubs>=0.3.11",
-    "mypy>=1.19.1,<2.5",
-    "pandas-stubs>=2.3.3.260113",
-    "plotly-stubs>=0.0.6",
-    "pre-commit>=4.5.1",
-    "pytest>=9.0.2",
-    "pytest-benchmark>=4.0.0",
-    "pytest-cov>=7.0.0",
-    "pytest-xdist>=3.8.0",
-    "pydata-sphinx-theme>=0.16.1",
-    "ruff>=0.11.0,<0.17", # upper-bound so a future ruff release cannot silently break the lint gate (see mypy)
-    "sphinx>=8.1.3",
-    "nbsphinx>=0.9.5",
-    "ipykernel>=6.29",
-    "tqdm-stubs>=0.2.1",
-    "watchdog>=6.0.0",
-]
-
 [project.scripts]
 process-improve-mcp = "process_improve.mcp_server:main"
 
@@ -147,6 +126,8 @@ requires = ["uv_build>=0.7.2,<0.14"]
 build-backend = "uv_build"
 
 [dependency-groups]
+# The contributors' tools. A dependency group rather than an extra, so the
+# published wheel does not offer them to users (#513).
 dev = [
     "coverage>=7.13.1",
     "hypothesis>=6.100",
@@ -249,6 +230,10 @@ ignore = [
 
     "C408",   # Unnecessary <dict/list/tuple> call - rewrite as a literal. Disagree with this.
 
+    # A `(str, Enum)` class turned into `StrEnum` changes what str() and format()
+    # return for its members, and these enums are public API.
+    "UP042",  # Class inherits from both `str` and `enum.Enum`
+
     # Arguments
     "ARG001", # Unusued argument
 

{process_improve-2.0.0 → process_improve-2.2.0}/src/process_improve/batch/_batch_plots.py

@@ -42,8 +42,7 @@ if typing.TYPE_CHECKING:
 
 _UNFOLDED_INDEX_ERROR = (
     "needs the 2-level (tag, sequence) index that process_improve.batch.dict_to_wide produces. "
-    "When scaling the unfolded matrix yourself, re-attach ``wide.columns`` after MCUVScaler, "
-    "which drops the multi-level labels."
+    "Fit the model to that matrix, or to MCUVScaler's output of it, which keeps the index."
 )
 
 
@@ -203,8 +202,7 @@ def unfolded_contribution_plot(
         ``t2_contributions`` on :class:`process_improve.batch.BatchPCA` or
         :class:`process_improve.batch.BatchPLS`, or of the standalone
         :mod:`process_improve.multivariate` functions on a model fitted to a
-        :func:`process_improve.batch.dict_to_wide` matrix whose column index
-        was re-attached after scaling.
+        :func:`process_improve.batch.dict_to_wide` matrix, scaled or not.
     batch_id : Hashable, optional
         Which batch (row) to plot. Defaults to the first row.
     by_tag : bool, default=False

{process_improve-2.0.0 → process_improve-2.2.0}/src/process_improve/batch/control.py

@@ -528,7 +528,10 @@ def midcourse_correction(  # noqa: PLR0913, PLR0912, PLR0915, C901
     # bisect each active multiplier down so the achieved statistic lands just
     # inside its cap instead of far below it (the escalation overshoots).
     # Each statistic is non-increasing in its own multiplier for this convex
-    # problem, so the per-coordinate bisection is well posed.
+    # problem, so the per-coordinate bisection is well posed. Lowering one
+    # multiplier can raise the other statistic, so a bisection step is taken
+    # only when both caps still hold: every accepted schedule meets both, and
+    # an "ok" status means they hold (#681).
     mu_spe = mu_t2 = 0.0
     n_solves = 0
     u_star = _solve(mu_spe, mu_t2)
@@ -538,6 +541,10 @@ def midcourse_correction(  # noqa: PLR0913, PLR0912, PLR0915, C901
     spe_cap_value = float("inf") if spe_cap is None else float(spe_cap)
     t2_cap_value = float("inf") if t2_cap is None else float(t2_cap)
     cap_status = "ok"
+
+    def _within_caps(spe: float, t2: float) -> bool:
+        return spe <= spe_cap_value * (1 + _CAP_REL_TOL) and t2 <= t2_cap_value * (1 + _CAP_REL_TOL)
+
     for _ in range(30):
         spe_bad = spe_value > spe_cap_value * (1 + _CAP_REL_TOL)
         t2_bad = t2_value > t2_cap_value * (1 + _CAP_REL_TOL)
@@ -561,12 +568,12 @@ def midcourse_correction(  # noqa: PLR0913, PLR0912, PLR0915, C901
                     mid = 0.5 * (low_mu + high_mu)
                     u_try = _solve(mid, mu_t2)
                     n_solves += 1
-                    spe_try, _t2_try = _statistics(u_try)
-                    if spe_try > spe_cap_value * (1 + _CAP_REL_TOL):
+                    spe_try, t2_try = _statistics(u_try)
+                    if not _within_caps(spe_try, t2_try):
                         low_mu = mid
                     else:
                         high_mu = mid
-                        u_star, spe_value, t2_value = u_try, spe_try, _t2_try
+                        u_star, spe_value, t2_value = u_try, spe_try, t2_try
                         if spe_try >= spe_cap_value * (1 - _CAP_REL_TOL):
                             break
                 mu_spe = high_mu
@@ -577,7 +584,7 @@ def midcourse_correction(  # noqa: PLR0913, PLR0912, PLR0915, C901
                     u_try = _solve(mu_spe, mid)
                     n_solves += 1
                     spe_try, t2_try = _statistics(u_try)
-                    if t2_try > t2_cap_value * (1 + _CAP_REL_TOL):
+                    if not _within_caps(spe_try, t2_try):
                         low_mu = mid
                     else:
                         high_mu = mid
@@ -585,9 +592,7 @@ def midcourse_correction(  # noqa: PLR0913, PLR0912, PLR0915, C901
                         if t2_try >= t2_cap_value * (1 - _CAP_REL_TOL):
                             break
                 mu_t2 = high_mu
-            spe_ok = spe_value <= spe_cap_value * (1 + _CAP_REL_TOL)
-            t2_ok = t2_value <= t2_cap_value * (1 + _CAP_REL_TOL)
-            if spe_ok and t2_ok:
+            if _within_caps(spe_value, t2_value):
                 break
 
     scores = b + A_F @ u_star
@@ -610,10 +615,22 @@ def midcourse_correction(  # noqa: PLR0913, PLR0912, PLR0915, C901
                 kind = name.split(":", 1)[0]
                 key = "bounds" if kind == "bound" else "rate"
                 typing.cast("list", active[key]).append(name.split(":", 1)[1])
+
+    def _binding(statistic: str) -> bool:
+        """Return whether a cap holds its statistic down: with its multiplier at zero, the statistic breaks it."""
+        nonlocal n_solves
+        n_solves += 1
+        if statistic == "spe":
+            return _statistics(_solve(0.0, mu_t2))[0] > spe_cap_value * (1 + _CAP_REL_TOL)
+        return _statistics(_solve(mu_spe, 0.0))[1] > t2_cap_value * (1 + _CAP_REL_TOL)
+
+    # A cap is active where its statistic sits at it (within the tolerance), or above it when it
+    # could not be met. Below it, a multiplier left over from the bisection is binding only if
+    # dropping it would break the cap: one bisected down because its cap is slack is not (#681).
     if spe_cap is not None:
-        active["spe_cap"] = bool(mu_spe > 0 or spe_value >= spe_cap_value * (1 - _CAP_REL_TOL))
+        active["spe_cap"] = spe_value >= spe_cap_value * (1 - _CAP_REL_TOL) or (mu_spe > 0 and _binding("spe"))
     if t2_cap is not None:
-        active["t2_cap"] = bool(mu_t2 > 0 or t2_value >= t2_cap_value * (1 - _CAP_REL_TOL))
+        active["t2_cap"] = t2_value >= t2_cap_value * (1 - _CAP_REL_TOL) or (mu_t2 > 0 and _binding("t2"))
 
     return Bunch(
         mv=mv,

{process_improve-2.0.0 → process_improve-2.2.0}/src/process_improve/batch/features.py

@@ -50,10 +50,12 @@ def _prepare_data(  # noqa: C901, PLR0912
     if phase_col is None:
         phase_col = "__phase_grouper__"
 
+    # The fake grouping columns are added with `assign`, which returns a new frame: an
+    # in-place `insert` added them to the caller's DataFrame as well.
     if phase_col not in df:
         # Cannot use "None" or 'nan'; else it won't group in the
         # groupby([batch_col, phase_col]) statement below.
-        df.insert(0, phase_col, "NoPhases")
+        df = df.assign(**{phase_col: "NoPhases"})
 
     # If no batch_col: add a fake column with all the same values
     if batch_col not in df or batch_col is None:
@@ -61,7 +63,7 @@ def _prepare_data(  # noqa: C901, PLR0912
         if batch_col not in df:
             # Cannot use "None" or 'nan'; else it won't group in the
             # groupby([batch_col, phase_col]) statement below.
-            df.insert(0, batch_col, 1)
+            df = df.assign(**{batch_col: 1})
 
     if tags is None:
         tags = list(df.columns)
@@ -226,12 +228,18 @@ def f_iqr(
     The difference between the 75th percentile and the 25th percentile of a
     sample this is the 25 % trimmed range, an example of an L - estimator.
 
-    See also: f_std
+    Missing values are omitted, as ``f_std`` and ``f_robust_mad`` omit them.
+
+    See also: f_std, f_robust_mad
     """
     base_name = "iqr"
+
+    def _iqr(col: pd.Series) -> float:
+        return float(iqr(col, nan_policy="omit"))
+
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
-    output = prepared.agg(iqr)
+    output = prepared.agg(_iqr)
     return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
@@ -282,8 +290,6 @@ def f_sum(
 
     If the x-axis (time) data are evenly-spaced, then this is directly
     proportional to the area under the trace (curve/trajectory).
-
-    See also: f_cumsum
     """
     base_name = "sum"
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
@@ -310,6 +316,9 @@ def f_area(
     The spacing of the x-axis is taken into account, so, this will produce
     accurate areas if the data are not evenly-spaced in time along the x-axis.
 
+    A datetime or timedelta time axis is measured in seconds, so the area is in the tag's
+    units multiplied by seconds. A numeric time axis is used in its own units.
+
     The area is calculated using the trapezoidal rule.
 
     See also: f_sum, f_cumsum
@@ -323,7 +332,13 @@ def f_area(
     for batch_id, this_batch in prepared:
         # Average width of the base * height. For time series, the average width of the base is
         # the same as the sampling intervals. Therefore the diff of the index.
-        half_base_factor = np.diff(this_batch.index)
+        time_axis = this_batch.index
+        if isinstance(time_axis, pd.DatetimeIndex | pd.TimedeltaIndex):
+            # A plain diff gives timedelta64 widths, which made the area a timedelta that a
+            # float column cannot hold. Seconds keep it a number in a stated unit.
+            half_base_factor = np.asarray(pd.TimedeltaIndex(time_axis[1:] - time_axis[:-1]).total_seconds())
+        else:
+            half_base_factor = np.diff(time_axis)
         for tag in tags:
             # Now the sum makes sense: gets the area under the curve by adding
             # up the smaller trapezoids: consider the trapezoids as rotated by 90 degrees.
@@ -433,7 +448,7 @@ def f_rupture(
     ``display`` helper that uses matplotlib; plotting belongs to the caller, and the rest
     of this project plots with plotly.
 
-    See also: f_elbow, f_cross
+    See also: f_elbow, f_crossing
     """
     default_settings: dict = {"model": "rbf", "penalty": None, "min_size": 2, "jump": 5}
     if settings:
@@ -779,8 +794,10 @@ def f_crossing(  # noqa: PLR0913
 
     f_name = tag + "_" + base_name
 
-    def _cross_first(x: pd.DataFrame) -> np.ndarray | list:
-        return cross(x[tag], threshold, direction, only_index=only_index, first_point_only=True)
+    def _cross_first(x: pd.DataFrame) -> np.ndarray | list | float:
+        crossing = cross(x[tag], threshold, direction, only_index=only_index, first_point_only=True)
+        # `cross` returns an empty array when there is no crossing; the documented feature is NaN.
+        return np.nan if np.size(crossing) == 0 else crossing
 
     # pandas-stubs' DFCallable1 protocol does not include ``np.ndarray`` among the allowed
     # return types, although groupby.apply accepts array-returning callables at runtime.
@@ -806,7 +823,7 @@ def f_elbow(  # noqa: PLR0913
     The elbow is calculated against whichever variable is given by `x_axis_tag` (usually a time-
     based tag).
 
-    The function returns the *value* on the x-axis where the elbox occurs. Sometimes you might
+    The function returns the *value* on the x-axis where the elbow occurs. Sometimes you might
     want the *index* of the value, so you can also find the corresponding y-axis value. Use
     `only_index=True` for such cases.
     """

{process_improve-2.0.0 → process_improve-2.2.0}/src/process_improve/batch/preprocessing.py

@@ -582,6 +582,10 @@ _HUBER_CUTOFF = 1.345
 #: Smallest batch weight :func:`_batch_weights` will return, so no batch is ever silenced.
 _MIN_BATCH_WEIGHT = 1e-3
 
+#: Iterations of :func:`batch_dtw` that align every batch to the ``reference_batch``. Each later
+#: iteration aligns to the average trajectory of the iteration before it.
+_ITERATIONS_ON_THE_REFERENCE_BATCH = 3
+
 
 def _batch_weights(aligned_batches: dict, batch_weighting: str) -> np.ndarray:
     """
@@ -721,7 +725,7 @@ def one_iteration_dtw(
             aligned_batches[batch_id] = result
             successful_alignments += 1
 
-        except ValueError as exc:  # noqa: PERF203
+        except ValueError as exc:
             # Chain the cause: a band constraint that is too narrow explains itself, and
             # that explanation is the actionable part. `from None` discarded it.
             raise ValueError(f"Failed on batch {batch_id}: {exc}") from exc
@@ -818,6 +822,11 @@ def batch_dtw(  # noqa: PLR0915
                 "interpolate_method": "cubic",         # any scipy.interpolate.interp1d method
             }
 
+        Every batch is aligned to ``reference_batch`` in the first three iterations. From
+        the fourth iteration on, the reference is the average trajectory of the iteration
+        before, so the result depends less on which batch was chosen as the reference. The
+        number three is fixed, not a setting.
+
         The default settings resample the time axis to 100 points, starting at 0 and ending
         at 99, so each point is one percent of the batch's duration however long the batch
         actually ran. Lower the delta for a finer axis (``0.5`` gives 200 points, ``0.25``
@@ -932,7 +941,12 @@ def batch_dtw(  # noqa: PLR0915
     average_batch = None
     delta_weight: np.floating | np.ndarray = np.linalg.norm(weight_vector)
     iter_step = 0
-    while (np.linalg.norm(delta_weight) > settings["tolerance"]) and (iter_step <= settings["maximum_iterations"]):
+    # The first iteration runs whatever the tolerance: it is the one that aligns the batches,
+    # and everything after the loop reads its results. A tolerance at or above the norm of
+    # the unit weights (the square root of the number of columns) used to skip it entirely.
+    while iter_step == 0 or (
+        (np.linalg.norm(delta_weight) > settings["tolerance"]) and (iter_step <= settings["maximum_iterations"])
+    ):
         if settings["show_progress"]:
             print(f"Iter = {iter_step} and norm = {np.linalg.norm(delta_weight)}")  # noqa: T201
 
@@ -946,7 +960,7 @@ def batch_dtw(  # noqa: PLR0915
         weight_matrix = np.diag(weight_vector)
         weight_history = np.vstack((weight_history, weight_vector.copy()))
 
-        if iter_step > 3:
+        if iter_step > _ITERATIONS_ON_THE_REFERENCE_BATCH:
             refbatch_sc = average_batch
 
         aligned_batches, average_batch = one_iteration_dtw(
@@ -1029,9 +1043,10 @@ def batch_dtw(  # noqa: PLR0915
         result.synced = synced_interpolated
         aligned_df_collection.append(synced_interpolated)
 
-    # Make the batch_id label consistent
+    # Each frame's batch_id column already holds its own dictionary key. Casting the whole
+    # column to the type of the last key turned an integer key into a string one whenever
+    # the keys were of mixed types, so the caller could no longer look its batch up.
     aligned_df = pd.concat(aligned_df_collection)
-    aligned_df["batch_id"] = aligned_df["batch_id"].astype(type(batch_id))
 
     last_average_batch = reverse_scaling(dict(avg=cast("pd.DataFrame", average_batch)), scale_df)["avg"]
     aligned_batch_dfdict = melted_to_dict(aligned_df, batch_id_col="batch_id")
@@ -1083,6 +1098,12 @@ def resample_to_reference(
     -------
     dict
         Batch data, in the standard format.
+
+    Raises
+    ------
+    ValueError
+        If a batch, the reference among them, has fewer than 2 rows: there is nothing to
+        interpolate between.
     """
     default_settings = {
         "interpolate_kind": "cubic",  # must be a valid "scipy.interpolate.interp1d" `kind`
@@ -1090,6 +1111,14 @@ def resample_to_reference(
     if settings:
         default_settings.update(settings)
     settings = default_settings
+    # Each batch's time axis is scaled to [0, 1] by dividing by its last row number, which is
+    # 0 for a single row: the division gave NaN and scipy then refused an "all-nan" axis.
+    too_short = {batch_id: batch.shape[0] for batch_id, batch in batches.items() if batch.shape[0] < 2}
+    if too_short:
+        raise ValueError(
+            f"resample_to_reference needs at least 2 rows in every batch, to interpolate between; "
+            f"these batches have fewer (batch: rows): {too_short}."
+        )
     out = {}
     target_time = np.arange(0, batches[reference_batch].shape[0])
     target_time = target_time / target_time[-1]

{process_improve-2.0.0 → process_improve-2.2.0}/src/process_improve/bivariate/_elbow_peak.py

@@ -26,6 +26,10 @@ def find_elbow_point(x: np.ndarray, y: np.ndarray, max_iter: int = 41) -> int |
     the median of the accumulated intersection points; the median location is
     where the intersections should stabilise.
 
+    Both axes are first scaled to span 0 to 1, so that "closest" does not add up
+    distances in two different units. The elbow is therefore the same whatever
+    units `x` and `y` are in: time in seconds or in hours gives the same index.
+
     Will probably not work well on few data points. If so, try fitting a spline
     to the raw data and then repeat with the interpolated data.
 
@@ -81,19 +85,22 @@ def find_elbow_point(x: np.ndarray, y: np.ndarray, max_iter: int = 41) -> int |
     if len(x) <= 10:
         raise ValueError("Requires more than 10 values in the vectors (not including missing data).")
     idx_sort = x.argsort()
-    x = x[idx_sort]
-    y = y[idx_sort]
+    x = _scale_to_unit_range(x[idx_sort])
+    y = _scale_to_unit_range(y[idx_sort])
     N = x.size
 
     int_x_list: list[float] = []
     int_y_list: list[float] = []
+    # On fewer than about 2 * max_iter points the floored window sizes repeat, so each size is
+    # fitted once. A repeat still adds its intersection again, which keeps the median unchanged.
+    intersections: dict[int, tuple] = {}
     for i in np.floor(np.linspace(0, int(N / 2 - start) + 1, max_iter)):
         idx = int(start + i)
-        lo_x, lo_y = x[0:idx], y[0:idx]
-        hi_x, hi_y = x[-idx:], y[-idx:]
-        lft = fit_robust_lm(lo_x, lo_y)
-        rgt = fit_robust_lm(hi_x, hi_y)
-        int_x, int_y = find_line_intersection(lft[1], lft[0], rgt[1], rgt[0])
+        if idx not in intersections:
+            lft = fit_robust_lm(x[0:idx], y[0:idx])
+            rgt = fit_robust_lm(x[-idx:], y[-idx:])
+            intersections[idx] = find_line_intersection(lft[1], lft[0], rgt[1], rgt[0])
+        int_x, int_y = intersections[idx]
         int_x_list.append(int_x)
         int_y_list.append(int_y)
 
@@ -110,6 +117,12 @@ def find_elbow_point(x: np.ndarray, y: np.ndarray, max_iter: int = 41) -> int |
     return int(np.argmin(calculate_line_length(mid_x, mid_y, x, y)))
 
 
+def _scale_to_unit_range(values: np.ndarray) -> np.ndarray:
+    """Shift and scale ``values`` to span 0 to 1; a constant vector is only shifted, to 0."""
+    span = float(np.ptp(values))
+    return (values - values.min()) / (span if span > 0 else 1.0)
+
+
 def find_line_intersection(m1: float, b1: float, m2: float, b2: float) -> tuple:
     """
     Find the intersection point of two lines.

{process_improve-2.0.0 → process_improve-2.2.0}/src/process_improve/config.py

@@ -251,7 +251,7 @@ class Settings:
 
     @property
     def max_memory_mb(self) -> int:
-        """Per-subprocess RSS cap for tool execution (MiB)."""
+        """Address space a tool's subprocess may map beyond what its imports mapped (MiB)."""
         return self._get("max_memory_mb", _read_env_int)
 
     @max_memory_mb.setter