DaSPi 2.1.0__tar.gz → 2.3.0__tar.gz

{daspi-2.1.0 → daspi-2.3.0}/PKG-INFO

@@ -1,8 +1,8 @@
 Metadata-Version: 2.1
 Name: DaSPi
-Version: 2.1.0
+Version: 2.3.0
 Summary: Visualize and analyze your data with DaSPi. This package is designed for users who want to find relevant influencing factors in processes and validate improvements.
-Author-Email: =?utf-8?q?Reto_J=C3=A4ggli?= <reto@jaeggli.email>
+Author-Email: Reto Jäggli <reto@jaeggli.email>
 License: MIT
 Project-URL: Repository, https://github.com/j4ggr/DaSPi
 Project-URL: Documentation, https://j4ggr.github.io/DaSPi/

daspi-2.3.0/daspi/__init__.py

@@ -0,0 +1,315 @@
+"""
+DaSPi — Process Analytics & Six Sigma in Python
+
+DaSPi helps engineers analyze and improve processes using statistical workflows.
+
+## Four Flagship Workflows
+
+1. **Gage R&R Analysis** — Verify measurement system capability (MSA Type 1 & 2)
+2. **Process Capability Analysis** — Evaluate if process meets specifications (Cp, Cpk)
+3. **Root Cause Analysis** — Identify factors that drive variation (ANOVA, regression)
+4. **Statistical Process Control** — Monitor process stability (SPC charts)
+
+Each workflow produces visual output + interpretation in under 20 lines of code.
+
+For detailed examples and documentation, visit: https://j4ggr.github.io/DaSPi/
+"""
+
+from ._version import __version__
+from .anova.convert import frames_to_html, get_term_name
+from .anova.model import (
+    GageRnRModel,
+    GageStudyModel,
+    GeneralizedLinearModel,
+    LinearModel,
+    hierarchical,
+    is_main_parameter,
+)
+from .anova.tables import (
+    anova_table,
+    terms_effect,
+    terms_probability,
+    uniques,
+    variance_inflation_factor,
+)
+from .config import CONFIG
+from .constants import (
+    ANOVA,
+    CATEGORY,
+    COLOR,
+    DEFAULT,
+    DIST,
+    KW,
+    LABEL,
+    LINE,
+    PLOTTER,
+    RE,
+    SIGMA_DIFFERENCE,
+)
+from .datasets import list_dataset, load_dataset
+from .doe import (
+    Factor,
+    FractionalFactorialDesignBuilder,
+    FullFactorial2kDesignBuilder,
+    FullFactorialDesignBuilder,
+    get_default_generators,
+)
+from .plotlib import style
+from .plotlib.chart import Chart, JointChart, MultivariateChart, SingleChart
+from .plotlib.classify import Dodger, HueLabel, ShapeLabel, SizeLabel
+from .plotlib.facets import AxesFacets, LabelFacets, StripesFacets, flat_unique
+from .plotlib.plotter import (
+    Bar,
+    Beeswarm,
+    BlandAltman,
+    Box,
+    CapabilityConfidenceInterval,
+    CategoricalObservation,
+    CenterLocation,
+    ConfidenceInterval,
+    DensityCurve,
+    ErrorBar,
+    FittedDensity,
+    GaussianKDE,
+    GaussianKDEContour,
+    GaussianKDEContourUnivariate,
+    HideSubplot,
+    Jitter,
+    Line,
+    LinearRegressionLine,
+    LoessLine,
+    MeanTest,
+    ParallelCoordinate,
+    Pareto,
+    Plotter,
+    Probability,
+    ProportionTest,
+    QuantileBoxes,
+    Scatter,
+    SkipSubplot,
+    SpreadWidth,
+    StandardErrorMean,
+    Stem,
+    StripeLine,
+    StripeSpan,
+    TransformPlotter,
+    VariationTest,
+    Violin,
+)
+from .plotlib.precast import (
+    BivariateUnivariateCharts,
+    GageRnRCharts,
+    GageStudyCharts,
+    PairComparisonCharts,
+    PairwiseMatrixCharts,
+    ParameterRelevanceCharts,
+    ProcessCapabilityAnalysisCharts,
+    ResidualsCharts,
+)
+from .statistics.confidence import (
+    bonferroni_ci,
+    confidence_to_alpha,
+    cp_ci,
+    cpk_ci,
+    delta_mean_ci,
+    delta_proportions_ci,
+    delta_stdev_ci,
+    delta_variance_ci,
+    fit_ci,
+    mean_ci,
+    median_ci,
+    prediction_ci,
+    proportion_ci,
+    sem,
+    stdev_ci,
+    variance_ci,
+)
+from .statistics.estimation import (
+    DistributionEstimator,
+    GageEstimator,
+    LocationDispersionEstimator,
+    Loess,
+    Lowess,
+    MeasurementUncertainty,
+    ProcessEstimator,
+    estimate_capability_confidence,
+    estimate_distribution,
+    estimate_kernel_density,
+    estimate_kernel_density_2d,
+    estimate_probability_density,
+    estimate_resolution,
+    root_sum_squares,
+)
+from .statistics.hypothesis import (
+    all_normal,
+    anderson_darling_test,
+    dunn_test,
+    f_test,
+    kolmogorov_smirnov_test,
+    kurtosis_test,
+    levene_test,
+    mean_stability_test,
+    pairwise_tests,
+    position_test,
+    proportions_test,
+    skew_test,
+    t_test,
+    variance_stability_test,
+    variance_test,
+)
+from .statistics.montecarlo import (
+    UNBOUNDED,
+    Binning,
+    RandomProcessValue,
+    Specification,
+    SpecLimits,
+    inclination_displacement,
+    round_to_nearest,
+)
+from .strings import STR
+
+__all__ = [
+    'ANOVA',
+    'CATEGORY',
+    'COLOR',
+    'CONFIG',
+    'DEFAULT',
+    'DIST',
+    'KW',
+    'LABEL',
+    'LINE',
+    'PLOTTER',
+    'RE',
+    'SIGMA_DIFFERENCE',
+    'STR',
+    'UNBOUNDED',
+    'AxesFacets',
+    'Bar',
+    'Beeswarm',
+    'Binning',
+    'BivariateUnivariateCharts',
+    'BlandAltman',
+    'Box',
+    'CapabilityConfidenceInterval',
+    'CategoricalObservation',
+    'CenterLocation',
+    'Chart',
+    'ConfidenceInterval',
+    'DensityCurve',
+    'DistributionEstimator',
+    'Dodger',
+    'ErrorBar',
+    'Factor',
+    'FittedDensity',
+    'FractionalFactorialDesignBuilder',
+    'FullFactorial2kDesignBuilder',
+    'FullFactorialDesignBuilder',
+    'GageEstimator',
+    'GageRnRCharts',
+    'GageRnRModel',
+    'GageStudyCharts',
+    'GageStudyModel',
+    'GaussianKDE',
+    'GaussianKDEContour',
+    'GaussianKDEContourUnivariate',
+    'GeneralizedLinearModel',
+    'HideSubplot',
+    'HueLabel',
+    'Jitter',
+    'JointChart',
+    'LabelFacets',
+    'Line',
+    'LinearModel',
+    'LinearRegressionLine',
+    'LocationDispersionEstimator',
+    'Loess',
+    'LoessLine',
+    'Lowess',
+    'MeanTest',
+    'MeasurementUncertainty',
+    'MultivariateChart',
+    'PairComparisonCharts',
+    'PairwiseMatrixCharts',
+    'ParallelCoordinate',
+    'ParameterRelevanceCharts',
+    'Pareto',
+    'Plotter',
+    'Probability',
+    'ProcessCapabilityAnalysisCharts',
+    'ProcessEstimator',
+    'ProportionTest',
+    'QuantileBoxes',
+    'RandomProcessValue',
+    'ResidualsCharts',
+    'Scatter',
+    'ShapeLabel',
+    'SingleChart',
+    'SizeLabel',
+    'SkipSubplot',
+    'SpecLimits',
+    'Specification',
+    'SpreadWidth',
+    'StandardErrorMean',
+    'Stem',
+    'StripeLine',
+    'StripeSpan',
+    'StripesFacets',
+    'TransformPlotter',
+    'VariationTest',
+    'Violin',
+    '__version__',
+    'all_normal',
+    'anderson_darling_test',
+    'anova_table',
+    'bonferroni_ci',
+    'confidence_to_alpha',
+    'cp_ci',
+    'cpk_ci',
+    'delta_mean_ci',
+    'delta_proportions_ci',
+    'delta_stdev_ci',
+    'delta_variance_ci',
+    'dunn_test',
+    'estimate_capability_confidence',
+    'estimate_distribution',
+    'estimate_kernel_density',
+    'estimate_kernel_density_2d',
+    'estimate_probability_density',
+    'estimate_resolution',
+    'f_test',
+    'fit_ci',
+    'flat_unique',
+    'frames_to_html',
+    'get_default_generators',
+    'get_term_name',
+    'hierarchical',
+    'inclination_displacement',
+    'is_main_parameter',
+    'kolmogorov_smirnov_test',
+    'kurtosis_test',
+    'levene_test',
+    'list_dataset',
+    'load_dataset',
+    'mean_ci',
+    'mean_stability_test',
+    'median_ci',
+    'pairwise_tests',
+    'position_test',
+    'prediction_ci',
+    'proportion_ci',
+    'proportions_test',
+    'root_sum_squares',
+    'round_to_nearest',
+    'sem',
+    'skew_test',
+    'stdev_ci',
+    'style',
+    't_test',
+    'terms_effect',
+    'terms_probability',
+    'uniques',
+    'variance_ci',
+    'variance_inflation_factor',
+    'variance_stability_test',
+    'variance_test',
+]

{daspi-2.1.0 → daspi-2.3.0}/daspi/_typing.py

@@ -9,6 +9,7 @@ from numpy.typing import NDArray
 from pandas.core.series import Series
 
 __all__ = [
+    'EstimationStrategy',
     'FloatOrArray',
     'LegendHandlesLabels',
     'LineStyle',
@@ -40,6 +41,16 @@ type ShareAxisProperty = (
     - 'col': share axes within each column
 """
 
+type EstimationStrategy = Literal['eval', 'fit', 'norm', 'data']
+"""Type alias for estimation strategies for evaluating the probability 
+density function (PDF).
+
+    - 'eval': evaluate the PDF using the given data
+    - 'fit': fit a distribution to the data and evaluate the PDF
+    - 'norm': assume a normal distribution and evaluate the PDF
+    - 'data': use the empirical data to estimate the PDF
+"""
+
 type LegendHandlesLabels = (
     tuple[tuple[Patch |Line2D, ...], tuple[str, ...]])
 """Type alias as tuple of maptlotlib legend handles and labels."""

{daspi-2.1.0 → daspi-2.3.0}/daspi/anova/model.py

@@ -76,7 +76,8 @@ import itertools
 import warnings
 from abc import ABC, abstractmethod
 from collections.abc import Generator
-from typing import Any, Literal, LiteralString, Self
+from functools import lru_cache
+from typing import Any, Literal, LiteralString, Self, overload
 
 import numpy as np
 import pandas as pd
@@ -110,19 +111,61 @@ __all__ = [
     'GageStudyModel',
     'GeneralizedLinearModel',
     'LinearModel',
-    'get_order',
     'hierarchical',
-    'is_main_parameter',]
+    'interaction_order',
+    'is_main_parameter',
+]
 
 
+@overload
+def _drop_intercept(data: DataFrame) -> DataFrame: ...
+@overload
+def _drop_intercept(data: Series) -> Series: ...
+def _drop_intercept(data: DataFrame | Series) -> DataFrame | Series:
+    """Drop the intercept index from a DataFrame or Series if it exists.
+
+    Parameters
+    ----------
+    data : DataFrame or Series
+        The input data from which to drop the intercept.
+
+    Returns
+    -------
+    DataFrame or Series
+        The input data with the intercept dropped, if it was present.
+    """
+    mask = ~data.index.str.contains(ANOVA.INTERCEPT, regex=False)
+    if isinstance(data, Series):
+        data = data[mask]
+    else:
+        data = data.loc[mask, :]
+    return data.copy()
+
 def is_main_parameter(parameter: str) -> bool:
     """Check if given parameter is a main parameter (intercept is 
     excluded)."""
     return parameter != ANOVA.INTERCEPT and ANOVA.SEP not in parameter
 
-def get_order(parameter: str) -> int:
+def interaction_order(parameter: str) -> int:
     """Get the order of a parameter (i.e., how many interactions it
-    contains)."""
+    contains).
+    
+    Parameters
+    ----------
+    parameter : str
+        The parameter name to check.
+        
+    Returns
+    -------
+    int
+        The interaction order of the parameter.
+        
+    Examples
+    --------
+    ```python
+    interaction_order('x1')  # Returns 1
+    interaction_order('x1:x2')  # Returns 2
+    ```"""
     return parameter.count(ANOVA.SEP) + 1
 
 def hierarchical(parameters: list[str]) -> list[str]:
@@ -139,21 +182,28 @@ def hierarchical(parameters: list[str]) -> list[str]:
     -------
     h_parameters : list of str
         Sorted factors for hierarchical model"""
-
+    return list(_hierarchical_cached(tuple(parameters)))
+
+@lru_cache(maxsize=128)
+def _hierarchical_cached(parameters: tuple[str, ...]) -> tuple[str, ...]:
+    """Cached implementation of `hierarchical`. Repeated calls with the
+    same (unchanged) set of terms, e.g. from `is_hierarchical` during a
+    single fit, are then resolved without recomputing all interaction
+    subsets."""
     h_parameters = set(parameters)
     for parameter in parameters:
         split = parameter.split(ANOVA.SEP)
-        n_splits = len(split)
-        for s in split:
-            h_parameters.add(s)
-        if n_splits <= ANOVA.SMALLEST_INTERACTION:
+        _order = len(split)
+        h_parameters.update(split)
+        if _order <= ANOVA.SMALLEST_INTERACTION_ORDER:
             continue
 
-        for i in range(ANOVA.SMALLEST_INTERACTION, n_splits):
-            for combo in map(ANOVA.SEP.join, itertools.combinations(split, i)):
-                h_parameters.add(combo)
+        h_parameters.update(
+            ANOVA.SEP.join(combo)
+            for i in range(ANOVA.SMALLEST_INTERACTION_ORDER, _order)
+            for combo in itertools.combinations(split, i))
 
-    return sorted(sorted(h_parameters), key=get_order)
+    return tuple(sorted(h_parameters, key=lambda p: (interaction_order(p), p)))
 
 
 class BaseHTMLReprModel(ABC):
@@ -671,21 +721,55 @@ class LinearModel(BaseHTMLReprModel):
         """Check if current fitted model is hierarchical."""
         return all(term in self.terms for term in hierarchical(self.terms))
     
-    def effects(self) -> Series:
+    def effects(self, include_intercept: bool = True) -> Series:
         """Calculates the impact of each term on the target. The
         effects are described as absolute number of the parameter 
-        coefficients devided by its standard error."""
+        coefficients devided by its standard error.
+        
+        Parameters
+        ----------
+        include_intercept : bool, optional
+            If False, the intercept is dropped from the returned
+            Series, by default True.
+
+        Returns
+        -------
+        Series
+            A Pandas Series containing the effects of each term on the 
+            target variable. The index of the Series corresponds to the 
+            term names, and the values represent the calculated effects.
+        """
         if self._effects.empty:
             self._effects = terms_effect(self.model)
         effects = self._effects.copy().rename(index=self.term_map)
+        if not include_intercept:
+            effects = _drop_intercept(effects)
         return effects
 
-    def p_values(self) -> 'Series[float]':
+    def p_values(self, include_intercept: bool = True) -> 'Series[float]':
         """Get P-value for significance of adding model terms using 
-        anova typ III table for current model."""
+        anova typ III table for current model.
+        
+        Parameters
+        ----------
+        include_intercept : bool, optional
+            If False, the intercept is dropped from the returned
+            Series, by default True.
+        
+        Returns
+        -------
+        Series
+            A Pandas Series containing the p-values of each term on the 
+            target variable. The index of the Series corresponds to the 
+            term names, and the values represent the calculated 
+            p-values.
+        """
         if self._p_values.empty:
             self._p_values = terms_probability(self.model)
-        return self._p_values.copy().rename(index=self.term_map)
+        p_values = self._p_values.copy().rename(index=self.term_map)
+        if not include_intercept:
+            p_values = _drop_intercept(p_values)
+        return p_values
 
     def least_parameter(self) -> str:
         """Get the parameter name with the least effect or the least 
@@ -706,20 +790,15 @@ class LinearModel(BaseHTMLReprModel):
         the term name with the least p-value for the F-stats coming from
         current ANOVA table.
         """
-        p_values = self.p_values().copy()
-        has_intercept = ANOVA.INTERCEPT in p_values.index
+        include_intercept = not self.skip_intercept_as_least
+        p_values = self.p_values(include_intercept)
         if any(p_values.isna()):
-            effects = self.effects().copy()
-            if has_intercept and self.skip_intercept_as_least:
-                effects = effects.drop(ANOVA.INTERCEPT)
-            if any(effects.isna()):
-                leasts = effects[effects.isna()]
-            else:
-                leasts = effects[effects == effects.min()]
-            least = max(leasts.index, key=get_order)
+            effects = self.effects(include_intercept).copy()
+            effect_mask = effects.isna()
+            if not any(effect_mask):
+                effect_mask = effects == effects.min()
+            least = max(effects[effect_mask].index, key=interaction_order )
         else:
-            if has_intercept and self.skip_intercept_as_least:
-                p_values = p_values.drop(ANOVA.INTERCEPT)
             least = p_values.iloc[::-1].idxmax()
         return str(least)
     
@@ -945,7 +1024,8 @@ class LinearModel(BaseHTMLReprModel):
             get_term_name(self.feature_map.get(x, x))
             for x in parameter.split(ANOVA.SEP))
         assert term in self.terms, (
-            f'Given term {term} is not in model')
+            f'Given term {term} (or "{parameter}") is not in model, '
+            f'got: {self.terms}')
         
         self.excluded.add(term)
         return self
@@ -985,7 +1065,7 @@ class LinearModel(BaseHTMLReprModel):
                 UserWarning)
         self.excluded.discard(term)
         return self
-
+    
     def recursive_elimination(
             self,
             rsquared_max: float = 0.99,

{daspi-2.1.0 → daspi-2.3.0}/daspi/anova/tables.py

@@ -97,9 +97,23 @@ def terms_effect(model: RegressionResultsWrapper) -> Series:
     Series
         A pandas Series containing the effects of each factor
         on the target variable.
+
+    Notes
+    -----
+    The effect size is calculated as the absolute value of the parameter
+    coefficient divided by its standard error. This is a measure of the
+    strength of the relationship between the predictor and the target
+    variable, with larger values indicating a stronger effect.
+
+    The index of the returned Series corresponds to the factor names in
+    the model, and the values represent the calculated effect sizes. 
+
+    Only terms that are present in the model are included in the output,
+    which is determined by filtering the effects based on the unique 
+    factor names derived from the model's design information.
     """
     params: Series = model.params
-    se: Series = model.scale
+    terms = model.model.data.design_info.term_names
     names_map = {n: get_term_name(n) for n in params.index}
     se = (model.bse
         .rename(index=names_map)
@@ -112,7 +126,7 @@ def terms_effect(model: RegressionResultsWrapper) -> Series:
         .groupby(level=0)
         .sum())
     effects = params.abs() / se
-    effects = effects[uniques(names_map.values())]
+    effects = effects[uniques(n for n in names_map.values() if n in terms)] # Filter out terms that are not in the model (this can happen when the model is imbalanced and some terms are dropped)
     effects.name = ANOVA.EFFECTS
     effects.index.name = ANOVA.FACTORS
     return effects

{daspi-2.1.0 → daspi-2.3.0}/daspi/constants.py

@@ -549,7 +549,7 @@ class _Anova_:
     """"Default name for source used in ANOVA table."""
     VIF: Literal['VIF'] = 'VIF'
     """"Default column name for VIF values in ANOVA table."""
-    SMALLEST_INTERACTION: int = 2
+    SMALLEST_INTERACTION_ORDER: int = 2
     """Smallest possible interaction"""
     RESIDUAL: Literal['Residual'] = 'Residual'
     """Name in anova table for residual (not explained) values."""

{daspi-2.1.0 → daspi-2.3.0}/daspi/plotlib/chart.py

@@ -67,7 +67,12 @@ from numpy.typing import NDArray
 from pandas.core.frame import DataFrame
 from pandas.core.series import Series
 
-from .._typing import LegendHandlesLabels, MosaicLayout, ShareAxisProperty
+from .._typing import (
+    EstimationStrategy,
+    LegendHandlesLabels,
+    MosaicLayout,
+    ShareAxisProperty,
+)
 from ..constants import CATEGORY, COLOR, KW, PLOTTER
 from ..statistics import UNBOUNDED, SpecLimits
 from ..strings import STR
@@ -1097,7 +1102,7 @@ class SingleChart(Chart):
             control_limits: bool = False, 
             spec_limits: SpecLimits = UNBOUNDED,
             confidence: float | None = None,
-            strategy: Literal['eval', 'fit', 'norm', 'data'] = 'norm',
+            strategy: EstimationStrategy = 'norm',
             agreement: float | int = 6,  # noqa: PYI041
             **kwds,
             ) -> Self:
@@ -1908,7 +1913,7 @@ class JointChart(Chart):
             control_limits: bool | tuple[bool, ...] = False, 
             spec_limits: SpecLimits | tuple[SpecLimits, ...] = UNBOUNDED,
             confidence: float | None | tuple[float | None, ...] = None,
-            strategy: Literal['eval', 'fit', 'norm', 'data'] | tuple = 'norm',
+            strategy: EstimationStrategy | tuple = 'norm',
             agreement: float | int | tuple[int | float, ...] = 6,  # noqa: PYI041
             **kwds) -> Self:
         """Plot location and spread width lines, specification limits 
@@ -2369,7 +2374,7 @@ class MultivariateChart(SingleChart):
             control_limits: bool = False, 
             spec_limits: SpecLimits = UNBOUNDED,
             confidence: float | None = None,
-            strategy: Literal['eval', 'fit', 'norm', 'data'] = 'norm',
+            strategy: EstimationStrategy = 'norm',
             agreement: float | int = 6,  # noqa: PYI041
             **kwds,
             ) -> Self:

{daspi-2.1.0 → daspi-2.3.0}/daspi/plotlib/facets.py

@@ -61,6 +61,7 @@ from matplotlib.typing import HashableList
 from numpy.typing import NDArray
 
 from .._typing import (
+    EstimationStrategy,
     LegendHandlesLabels,
     MosaicLayout,
     NumericSample1D,
@@ -475,7 +476,7 @@ class StripesFacets:
         control_limits: bool = False,
         spec_limits: SpecLimits = UNBOUNDED,
         confidence: float | None = None,
-        strategy: Literal['eval', 'fit', 'norm', 'data'] = 'norm',
+        strategy: EstimationStrategy = 'norm',
         agreement: float | int = 6,  # noqa: PYI041
         **kwds) -> None:
         self.single_axes = single_axes