process-improve 1.2.0__tar.gz → 1.2.6__tar.gz

{process_improve-1.2.0 → process_improve-1.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: process-improve
-Version: 1.2.0
+Version: 1.2.6
 Summary: Designed Experiments; Latent Variables (PCA, PLS, multivariate methods with missing data); Process Monitoring; Batch data analysis.
 Keywords: Designed Experiments,Latent Variables,PCA,PLS,Multivariate Data Analysis,Batch data analysis
 Author: Kevin Dunn
@@ -20,11 +20,26 @@ Requires-Dist: scikit-learn>=1.7.2
 Requires-Dist: seaborn>=0.13.2
 Requires-Dist: statsmodels>=0.14.6
 Requires-Dist: tqdm>=4.67.1
+Requires-Dist: coverage>=7.13.1 ; extra == 'dev'
+Requires-Dist: matplotlib-stubs>=0.3.11 ; extra == 'dev'
+Requires-Dist: mypy>=1.19.1 ; 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-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 ; extra == 'dev'
+Requires-Dist: sphinx>=8.1.3 ; extra == 'dev'
+Requires-Dist: tqdm-stubs>=0.2.1 ; extra == 'dev'
+Requires-Dist: watchdog>=6.0.0 ; extra == 'dev'
 Requires-Dist: mcp>=1.0 ; extra == 'mcp'
 Requires-Python: >=3.10
 Project-URL: Homepage, https://github.com/kgdunn/process_improve
 Project-URL: Repository, https://github.com/kgdunn/process_improve
 Project-URL: Issues, https://github.com/kgdunn/process_improve/issues
+Provides-Extra: dev
 Provides-Extra: mcp
 Description-Content-Type: text/markdown
 

{process_improve-1.2.0 → process_improve-1.2.6}/process_improve/batch/alignment_helpers.py

@@ -5,7 +5,8 @@ from numba import jit
 
 
 @jit(nopython=True)
-def distance_matrix(test: np.ndarray, ref: np.ndarray, weight_matrix: np.ndarray):
+def distance_matrix(test: np.ndarray, ref: np.ndarray, weight_matrix: np.ndarray) -> np.ndarray:
+    """Compute the DTW distance matrix between test and reference batch trajectories."""
     # TODO: allow user to specify `band`. The code below assumes that `band` is fixed as shown
     # here, so therefore, if user provide `band`, the code needs to be adjusted.
     nt = test.shape[0]  # 'test' data; will be align to the 'reference' data
@@ -36,7 +37,8 @@ def distance_matrix(test: np.ndarray, ref: np.ndarray, weight_matrix: np.ndarray
 
 
 @jit(nopython=True)
-def backtrack_optimal_path(D: np.ndarray):
+def backtrack_optimal_path(D: np.ndarray) -> tuple[list, float]:
+    """Backtrack through the distance matrix to find the optimal warping path."""
     nr, nt = D.shape
     nr -= 1
     nt -= 1

{process_improve-1.2.0 → process_improve-1.2.6}/process_improve/batch/data_input.py

@@ -36,12 +36,13 @@ Characteristics:
 - the multilevel column index has level 0 = column name, level 1 = aligned time
 - only makes sense if the data are aligned (same number of elements in each level-1 index)
 """
+from __future__ import annotations
 
 import numpy as np
 import pandas as pd
 
 
-def check_valid_batch_dict(in_dict: dict, no_nan=False) -> bool:
+def check_valid_batch_dict(in_dict: dict, no_nan: bool = False) -> bool:
     """Check if the incoming dictionary of batch data is a valid dictionary of data.
 
     Checks:
@@ -87,7 +88,11 @@ def check_valid_batch_dict(in_dict: dict, no_nan=False) -> bool:
     return bool(check)
 
 
-def dict_to_melted(in_df: pd.DataFrame, insert_batch_id_column=True, insert_sequence_column=False) -> pd.DataFrame:
+def dict_to_melted(
+    in_df: pd.DataFrame,
+    insert_batch_id_column: bool = True,
+    insert_sequence_column: bool = False,
+) -> pd.DataFrame:
     """Reverse of `melted_to_dict`."""
     batch_id_col = "batch_id"
     all_batches = []
@@ -111,7 +116,7 @@ def dict_to_melted(in_df: pd.DataFrame, insert_batch_id_column=True, insert_sequ
     return pd.concat(all_batches)
 
 
-def dict_to_wide(in_df: dict, group_by_batch=False) -> pd.DataFrame:
+def dict_to_wide(in_df: dict, group_by_batch: bool = False) -> pd.DataFrame:
     """
     Convert aligned batch data from dict to wide format.
 
@@ -131,22 +136,18 @@ def dict_to_wide(in_df: dict, group_by_batch=False) -> pd.DataFrame:
     return aligned_wide_df
 
 
-def melted_to_dict(in_df: pd.DataFrame, batch_id_col) -> dict:
+def melted_to_dict(in_df: pd.DataFrame, batch_id_col: str) -> dict:
     """
     Load a "melted" data set, where one of the columns is the `batch_id_col`.
     The data are grouped along the unique values of `batch_id_col`, and each group is stored
     in a dictionary. The dictionary keys are the batch identifier, and the corresponding value
     is a Pandas dataframe of the batch data for that batch.
     """
-    batches = {}
     assert batch_id_col in in_df, "The `batch_id_col` column does not exist in the incoming dataframe."
-    for batch_id, batch in in_df.groupby(batch_id_col):
-        batches[batch_id] = batch
+    return {batch_id: batch for batch_id, batch in in_df.groupby(batch_id_col)}  # noqa: C416
 
-    return batches
 
-
-def melted_to_wide(in_df: pd.DataFrame, batch_id_col) -> dict:
+def melted_to_wide(in_df: pd.DataFrame, batch_id_col: str) -> dict:
     """Convert aligned melted data to wide format."""
     assert batch_id_col in in_df
     return {}
@@ -166,15 +167,16 @@ def melted_to_wide(in_df: pd.DataFrame, batch_id_col) -> dict:
 
 
 def wide_to_melted(in_df: pd.DataFrame) -> pd.DataFrame:
+    """Convert wide-format batch data to melted format. Not yet implemented."""
     # dict_to_melted(dict_to_wide(in_df))
     return pd.DataFrame()
 
 
-def wide_to_dict():
-    pass
+def wide_to_dict() -> None:
+    """Convert wide-format batch data to dict format. Not yet implemented."""
 
 
-def melt_df_to_series(in_df: pd.DataFrame, exclude_columns=None, name=None) -> pd.Series:
+def melt_df_to_series(in_df: pd.DataFrame, exclude_columns: list | None = None, name: str | None = None) -> pd.Series:
     """Return a Series with a multilevel-index, melted from the DataFrame."""
     if exclude_columns is None:
         exclude_columns = ["batch_id"]

{process_improve-1.2.0 → process_improve-1.2.6}/process_improve/batch/features.py

@@ -1,5 +1,7 @@
 from __future__ import annotations
 
+import warnings
+
 import numpy as np
 import pandas as pd
 from scipy.stats import iqr, norm
@@ -11,7 +13,13 @@ from ..regression.methods import repeated_median_slope
 # ------------------------------------------
 
 
-def _prepare_data(df: pd.DataFrame, tags=None, batch_col=None, phase_col=None, age_col=None):  # noqa: C901, PLR0912
+def _prepare_data(  # noqa: C901, PLR0912
+    df: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+    age_col: str | None = None,
+) -> tuple[pd.core.groupby.DataFrameGroupBy, list[str], pd.DataFrame, pd.DataFrame]:
     """
     General function, used for all feature extractions.
 
@@ -96,7 +104,12 @@ def _prepare_data(df: pd.DataFrame, tags=None, batch_col=None, phase_col=None, a
 
 # Location-based features
 # ------------------------------------------
-def f_mean(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_mean(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    mean.
 
@@ -108,10 +121,15 @@ def f_mean(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.mean()
-    return output.rename(columns=dict(zip(tags, f_names)))[f_names]
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))[f_names]
 
 
-def f_median(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_median(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    median.
 
@@ -119,7 +137,7 @@ def f_median(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     indicator column, and within each unique phase, per batch, of the ``phase_col`` column.
     """
     base_name = "median"
-    prepared, tags, output, df_out = _prepare_data(data, tags, batch_col, phase_col)
+    prepared, tags, output, _df_out = _prepare_data(data, tags, batch_col, phase_col)
 
     # If the feature is to be calculated within a specific range of time, then provide the
     # `slicer` input and the name of the `age_col` (column containing time evolution) which is
@@ -151,12 +169,17 @@ def f_median(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
 
     output = prepared.median()
     f_names = [(tag + "_" + base_name) for tag in tags]
-    return output.rename(columns=dict(zip(tags, f_names)))[f_names]
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))[f_names]
 
 
 # Scale-based features
 # ------------------------------------------
-def f_std(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_std(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    std.
 
@@ -170,10 +193,15 @@ def f_std(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.std()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_iqr(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_iqr(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    iqr.
 
@@ -191,10 +219,15 @@ def f_iqr(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.agg(iqr)
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_mad(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_mad(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    mad.
 
@@ -216,10 +249,15 @@ def f_mad(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.mad()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_robust_mad(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_robust_mad(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    mad.
 
@@ -252,12 +290,17 @@ def f_robust_mad(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     raise AssertionError("This next line of code fails. Fix it.")
     output = (np.fabs(prepared - prepared.median())).median() / c_MAD_const
 
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
 # Cumulative features
 # ------------------------------------------
-def f_sum(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_sum(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    sum.
 
@@ -274,10 +317,16 @@ def f_sum(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.sum()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_area(data: pd.DataFrame, time_tag, tags=None, batch_col=None, phase_col=None):
+def f_area(
+    data: pd.DataFrame,
+    time_tag: str,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    area.
 
@@ -310,7 +359,9 @@ def f_area(data: pd.DataFrame, time_tag, tags=None, batch_col=None, phase_col=No
             # heights on the left and the right, multiplied by delta distance on the horizontal
             # index axis. Area = average(parallel lengths) * height
             # where height = delta distance on the horizontal axis.
-            area = ((this_batch[tag].iloc[0:-1].values + this_batch[tag].iloc[1:].values) / 2 * half_base_factor).sum()
+            left_vals = this_batch[tag].iloc[0:-1].values
+            right_vals = this_batch[tag].iloc[1:].values
+            area = ((left_vals + right_vals) / 2 * half_base_factor).sum()
             output.loc[batch_id, tag] = area
 
             # TODO: check this out still
@@ -323,12 +374,17 @@ def f_area(data: pd.DataFrame, time_tag, tags=None, batch_col=None, phase_col=No
             # ) / 2
 
     # output.add_suffix('_' + base_name)
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
 # Breakpoint detection:  rupture / breakpoint within a particular tag.
 # ------------------------------------------
-def f_rupture(data: pd.DataFrame, columns=None, batch_col=None, phase_col=None):
+def f_rupture(
+    data: pd.DataFrame,
+    columns: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> None:
     """
     Feature:    rupture.
 
@@ -361,7 +417,12 @@ def f_rupture(data: pd.DataFrame, columns=None, batch_col=None, phase_col=None):
 
 # Extreme features
 # ------------------------------------------
-def f_min(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_min(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    min.
 
@@ -377,10 +438,15 @@ def f_min(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.min()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_max(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_max(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    max.
 
@@ -396,20 +462,35 @@ def f_max(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.max()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_agemin(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_agemin(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> None:
+    """Feature: age at minimum value. Not yet implemented."""
     # TODO
-    pass
 
 
-def f_agemax(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_agemax(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> None:
+    """Feature: age at maximum value. Not yet implemented."""
     # TODO
-    pass
 
 
-def f_last(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_last(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    endpoint.
 
@@ -426,10 +507,15 @@ def f_last(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.last()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
-def f_count(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
+def f_count(
+    data: pd.DataFrame,
+    tags: list[str] | None = None,
+    batch_col: str | None = None,
+    phase_col: str | None = None,
+) -> pd.DataFrame:
     """
     Feature:    count.
 
@@ -446,15 +532,15 @@ def f_count(data: pd.DataFrame, tags=None, batch_col=None, phase_col=None):
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col)
     f_names = [(tag + "_" + base_name) for tag in tags]
     output = prepared.count()
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
 # Shape-based features
 # ------------------------------------------
-def f_slope(
+def f_slope(  # noqa: PLR0913
     data: pd.DataFrame,
     x_axis_tag: str,
-    tags=None,
+    tags: list[str] | None = None,
     batch_col: str | None = None,
     phase_col: str | None = None,
     age_col: str | None = None,
@@ -475,14 +561,14 @@ def f_slope(
 
     # We will overwrite all entries in this dataframe, one-by-one
     output = prepared.sum()
-    for batch_id, this_batch in prepared:
-        if x_axis_tag not in this_batch:
-            this_batch = this_batch.reset_index()
+    for batch_id, batch_data in prepared:
+        if x_axis_tag not in batch_data:
+            batch_data = batch_data.reset_index()  # noqa: PLW2901
         for tag in tags:
-            X = this_batch[x_axis_tag]
-            output.loc[batch_id, tag] = repeated_median_slope(X, this_batch[tag])
+            x_vals = batch_data[x_axis_tag]
+            output.loc[batch_id, tag] = repeated_median_slope(x_vals, batch_data[tag])
 
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))
 
 
 def cross(
@@ -548,7 +634,7 @@ def cross(
     return x_crossings
 
 
-def f_crossing(
+def f_crossing(  # noqa: PLR0913
     data: pd.DataFrame,
     tag: str,
     time_tag: str,
@@ -584,7 +670,7 @@ def f_crossing(
     assert isinstance(tag, str)
     assert tag in data, f"Desired tag ['{tag}'] not found in the dataframe."
 
-    prepared, tags, output, _ = _prepare_data(
+    prepared, _tags, output, _ = _prepare_data(
         data,
         [tag],
         batch_col,
@@ -594,15 +680,17 @@ def f_crossing(
 
     f_name = tag + "_" + base_name
 
-    output = prepared.apply(lambda x: cross(x[tag], threshold, direction, only_index=only_index, first_point_only=True))
+    output = prepared.apply(
+        lambda x: cross(x[tag], threshold, direction, only_index=only_index, first_point_only=True)
+    )
 
     return pd.DataFrame(data={f_name: output})
 
 
-def f_elbow(
+def f_elbow(  # noqa: PLR0913
     data: pd.DataFrame,
     x_axis_tag: str,
-    tags=None,
+    tags: list[str] | None = None,
     only_index: bool | None = False,
     batch_col: str | None = None,
     phase_col: str | None = None,
@@ -620,26 +708,24 @@ def f_elbow(
     want the *index* of the value, so you can also find the corresponding y-axis value. Use
     `only_index=True` for such cases.
     """
-    import warnings
-
     base_name = "elbow"
     prepared, tags, output, _ = _prepare_data(data, tags, batch_col, phase_col, age_col=x_axis_tag)
     f_names = [(tag + "_" + base_name) for tag in tags]
 
     # We will overwrite all entries in this dataframe, one-by-one
     output = prepared.sum()
-    for batch_id, this_batch in prepared:
-        if x_axis_tag not in this_batch:
-            this_batch = this_batch.reset_index()
+    for batch_id, batch_data in prepared:
+        if x_axis_tag not in batch_data:
+            batch_data = batch_data.reset_index()  # noqa: PLW2901
         for tag in tags:
-            subset = this_batch[[x_axis_tag, tag]]
+            subset = batch_data[[x_axis_tag, tag]]
             subset = subset.dropna()
-            X = subset[x_axis_tag]
+            x_vals = subset[x_axis_tag]
 
             with warnings.catch_warnings():
                 warnings.simplefilter("ignore")
 
-                elbow_index = find_elbow_point(X, subset[tag])
+                elbow_index = find_elbow_point(x_vals, subset[tag])
                 if elbow_index < 0:
                     elbow_index = np.nan
 
@@ -648,6 +734,6 @@ def f_elbow(
                 elif np.isnan(elbow_index):
                     output.loc[batch_id][tag] = np.isnan
                 else:
-                    output.loc[batch_id][tag] = X[elbow_index]
+                    output.loc[batch_id][tag] = x_vals[elbow_index]
 
-    return output.rename(columns=dict(zip(tags, f_names)))
+    return output.rename(columns=dict(zip(tags, f_names, strict=False)))