DaSPi 2.5.0__tar.gz → 2.7.0__tar.gz

{daspi-2.5.0 → daspi-2.7.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: DaSPi
-Version: 2.5.0
+Version: 2.7.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: Reto Jäggli <reto@jaeggli.email>
 License: MIT

{daspi-2.5.0 → daspi-2.7.0}/daspi/__init__.py

@@ -80,6 +80,7 @@ if TYPE_CHECKING:
         ConfidenceInterval,
         DensityCurve,
         ErrorBar,
+        ExponentialSmoothingLine,
         FittedDensity,
         GaussianKDE,
         GaussianKDEContour,
@@ -90,6 +91,7 @@ if TYPE_CHECKING:
         LinearRegressionLine,
         LoessLine,
         MeanTest,
+        MovingAverageLine,
         ParallelCoordinate,
         Pareto,
         Plotter,
@@ -240,6 +242,7 @@ _LAZY_SUBMODULES: dict[str, str] = {
     'ConfidenceInterval': '.plotlib.plotter',
     'DensityCurve': '.plotlib.plotter',
     'ErrorBar': '.plotlib.plotter',
+    'ExponentialSmoothingLine': '.plotlib.plotter',
     'FittedDensity': '.plotlib.plotter',
     'GaussianKDE': '.plotlib.plotter',
     'GaussianKDEContour': '.plotlib.plotter',
@@ -250,6 +253,7 @@ _LAZY_SUBMODULES: dict[str, str] = {
     'LinearRegressionLine': '.plotlib.plotter',
     'LoessLine': '.plotlib.plotter',
     'MeanTest': '.plotlib.plotter',
+    'MovingAverageLine': '.plotlib.plotter',
     'ParallelCoordinate': '.plotlib.plotter',
     'Pareto': '.plotlib.plotter',
     'Plotter': '.plotlib.plotter',
@@ -376,6 +380,7 @@ __all__ = [
     'DistributionEstimator',
     'Dodger',
     'ErrorBar',
+    'ExponentialSmoothingLine',
     'Factor',
     'FittedDensity',
     'FractionalFactorialDesignBuilder',
@@ -404,6 +409,7 @@ __all__ = [
     'Lowess',
     'MeanTest',
     'MeasurementUncertainty',
+    'MovingAverageLine',
     'MultivariateChart',
     'GoodnessOfFitCharts',
     'PairComparisonCharts',

{daspi-2.5.0 → daspi-2.7.0}/daspi/anova/model.py

@@ -376,12 +376,13 @@ class LinearModel(BaseHTMLReprModel):
         covariates=['temperature', 'preparation'],
         order=2,)
 
-    # Store goodnes of fit values for each elimination step
+    # Store and visualize goodnes of fit values for each elimination step
     df_gof = pd.concat(model.recursive_elimination())
+    dsp.GoodnessOfFitCharts(df_gof, model).plot().stripes().label(info=True)
 
     # Plot residual and parameter relevance analysis
     dsp.ResidualsCharts(model).plot().stripes().label(info=True)
-    dsp.ParameterRelevanceCharts(model).plot().label(info=True)
+    dsp.ParameterRelevanceCharts(model).plot().stripes().label(info=True)
 
     # Get HTML output
     model

{daspi-2.5.0 → daspi-2.7.0}/daspi/constants.py

@@ -203,6 +203,12 @@ class _Kw_:
         """Keyword arguments for confidence interval area for fit."""
         return {'zorder': 2.2, 'alpha': 0.8, 'marker': ''}
 
+    @property
+    def FIT_LINE_HANDLE(self) -> dict[str, Any]:
+        """Keyword arguments for the legend handle of a fitted line
+        (e.g. `MovingAverageLine`, `ExponentialSmoothingLine`)."""
+        return {'lw': LINE.WIDTH, 'alpha': 0.8}
+
     @property
     def FIT_CI(self) -> dict[str, Any]:
         """Keyword arguments for confidence interval area for fit."""
@@ -520,6 +526,14 @@ class _Plotter_:
     SUBGROUP: Literal['_subgroup_'] = '_subgroup_'
     """Column name for subgroups used mostly in TransformPlotter."""
 
+    SMOOTHED_TARGET: Literal['_smoothed_target_'] = '_smoothed_target_'
+    """Column name for smoothed target values (moving average,
+    exponential smoothing)."""
+
+    SMOOTHED_FEATURE: Literal['_smoothed_feature_'] = '_smoothed_feature_'
+    """Column name for the feature values matching the smoothed target
+    values (moving average, exponential smoothing)."""
+
     @property
     def REGRESSION_CI_NAMES(self) -> tuple[str, str, str, str]:
         """Get names for regression confidences in order:
@@ -788,6 +802,13 @@ class _Default_:
     - 6 = ±3 σ, capturing about 99.7% of the data.
     """
 
+    MA_WINDOW: Literal[5] = 5
+    """Default window size for the `MovingAverageLine` Plotter."""
+
+    EWM_ALPHA: float = 0.3
+    """Default smoothing factor (alpha) for the
+    `ExponentialSmoothingLine` Plotter."""
+
     @property
     def MARKER(self) -> str:
         """Default marker for scatter plots."""

{daspi-2.5.0 → daspi-2.7.0}/daspi/plotlib/chart.py

@@ -62,6 +62,7 @@ import pandas as pd
 from matplotlib.axes import Axes
 from matplotlib.axis import XAxis, YAxis
 from matplotlib.figure import Figure
+from matplotlib.lines import Line2D
 from matplotlib.ticker import AutoMinorLocator, Formatter
 from numpy.typing import NDArray
 from pandas.core.frame import DataFrame
@@ -113,7 +114,7 @@ def check_label_order[T](method: Callable[..., T]) -> Callable[..., T]:
         If the decorated method is called after label() method.
     """
     @wraps(method)
-    def wrapper(self: Chart, *args: Any, **kwargs: Any) -> T:
+    def wrapper(self: 'Chart', *args: Any, **kwargs: Any) -> T:
         assert not hasattr(self, 'label_facets'), (
             f'Cannot call {method.__name__}() after label(). '
             'The label() method must be called after stripes() and plot().')
@@ -121,6 +122,21 @@ def check_label_order[T](method: Callable[..., T]) -> Callable[..., T]:
     return wrapper
 
 
+_XY_SET_PARAMS: dict[str, tuple[str, str]] = {
+    'lim': ('xlim', 'ylim'),
+    'bound': ('xbound', 'ybound'),
+    'margin': ('xmargin', 'ymargin'),
+    'scale': ('xscale', 'yscale'),
+    'ticks': ('xticks', 'yticks'),
+    'ticklabels': ('xticklabels', 'yticklabels'),
+    'inverted': ('xinverted', 'yinverted'),
+    'autoscale': ('autoscalex_on', 'autoscaley_on'),
+}
+"""Mapping of generic axis parameters to their corresponding Axes.set 
+keys. The keys correspond to the parameters used in the `Axes.set` 
+method for the x and y axes, respectively."""
+
+
 class Chart(ABC):
     """
     Abstract base class for creating chart visualizations.
@@ -443,6 +459,124 @@ class Chart(ABC):
         enhance readability and provide context for the visualized data.
         """
     
+    @check_label_order
+    def set(
+            self,
+            ax: int | tuple[int, int] | Literal['all', 'first', 'last'] | None = 'all',
+            *,
+            feature_lim: tuple[float, float] | None = None,
+            target_lim: tuple[float, float] | None = None,
+            feature_bound: tuple[float, float] | None = None,
+            target_bound: tuple[float, float] | None = None,
+            feature_margin: float | None = None,
+            target_margin: float | None = None,
+            feature_scale: str | None = None,
+            target_scale: str | None = None,
+            feature_ticks: Sequence[float] | None = None,
+            target_ticks: Sequence[float] | None = None,
+            feature_ticklabels: Sequence[str] | None = None,
+            target_ticklabels: Sequence[str] | None = None,
+            feature_inverted: bool | None = None,
+            target_inverted: bool | None = None,
+            feature_autoscale: bool | None = None,
+            target_autoscale: bool | None = None,
+            **kwds: Any,
+            ) -> Self:
+        """Set properties on one, several or all Axes of this chart.
+
+        This is a thin wrapper around matplotlib's
+        ``Axes.set(**kwargs)``. The `feature_*`/`target_*` keywords
+        mirror the x/y-paired properties of ``Axes.set`` (e.g. `xlim`
+        and `ylim`) but are named after the chart's feature and target
+        variable instead, so they resolve to the correct axis based on
+        the `target_on_y` attribute. All other matplotlib ``Axes.set``
+        properties that have no x/y counterpart (e.g. `title`,
+        `aspect`, `facecolor`) can be passed directly via `**kwds`.
+
+        Note that `xlabel`/`ylabel` are intentionally not supported
+        here, use the `label()` method to set axis labels instead.
+
+        Parameters
+        ----------
+        ax : int | tuple[int, int] | {'all', 'first', 'last'} | None, optional
+            Selects which Axes the properties are applied to:
+            - int or tuple[int, int]: the Axes at that position in the
+              `axes` grid (see `AxesFacets.__getitem__`).
+            - 'all': every Axes in the grid, by default.
+            - 'first': only the first Axes in the grid.
+            - 'last': only the last Axes in the grid.
+            - None: the Axes that was last worked on (falls back to the
+              default Axes if none was worked on yet).
+        feature_lim, target_lim : tuple[float, float], optional
+            Feature/target axis view limits (`xlim`/`ylim`).
+        feature_bound, target_bound : tuple[float, float], optional
+            Feature/target axis bounds (`xbound`/`ybound`).
+        feature_margin, target_margin : float, optional
+            Feature/target axis margins (`xmargin`/`ymargin`).
+        feature_scale, target_scale : str, optional
+            Feature/target axis scale (`xscale`/`yscale`).
+        feature_ticks, target_ticks : Sequence[float], optional
+            Feature/target axis tick locations (`xticks`/`yticks`).
+        feature_ticklabels, target_ticklabels : Sequence[str], optional
+            Feature/target axis tick labels
+            (`xticklabels`/`yticklabels`).
+        feature_inverted, target_inverted : bool, optional
+            Whether the feature/target axis is inverted
+            (`xinverted`/`yinverted`).
+        feature_autoscale, target_autoscale : bool, optional
+            Whether the feature/target axis autoscales
+            (`autoscalex_on`/`autoscaley_on`).
+        **kwds
+            Additional keyword arguments forwarded as-is to
+            `Axes.set()`, for properties without a feature/target
+            counterpart (e.g. `title`, `aspect`, `facecolor`,
+            `visible`, `zorder`).
+
+        Returns
+        -------
+        Self
+            The updated Chart object.
+        """
+        feature_values = {
+            'lim': feature_lim, 'bound': feature_bound,
+            'margin': feature_margin, 'scale': feature_scale,
+            'ticks': feature_ticks, 'ticklabels': feature_ticklabels,
+            'inverted': feature_inverted, 'autoscale': feature_autoscale}
+        target_values = {
+            'lim': target_lim, 'bound': target_bound,
+            'margin': target_margin, 'scale': target_scale,
+            'ticks': target_ticks, 'ticklabels': target_ticklabels,
+            'inverted': target_inverted, 'autoscale': target_autoscale}
+
+        feature_axis = 0 if self.target_on_y else 1
+        target_axis = 1 if self.target_on_y else 0
+        kwds = dict(kwds)
+        for name, value in feature_values.items():
+            if value is not None:
+                kwds[_XY_SET_PARAMS[name][feature_axis]] = value
+        for name, value in target_values.items():
+            if value is not None:
+                kwds[_XY_SET_PARAMS[name][target_axis]] = value
+
+        if ax == 'all':
+            axes = self.axes.flat
+        elif ax == 'first':
+            axes = [self.axes.flat[0]]
+        elif ax == 'last':
+            axes = [self.axes.flat[-1]]
+        elif ax is None:
+            current = self._ax if self._ax is not None else self.axes.ax
+            assert current is not None, (
+                'No current Axes to set properties on, specify `ax` '
+                'explicitly.')
+            axes = [current]
+        else:
+            axes = [self.axes[ax]]
+
+        for _ax in axes:
+            _ax.set(**kwds)
+        return self
+    
     def save(
             self,
             file_name: str | Path,
@@ -740,6 +874,14 @@ class SingleChart(Chart):
             handle_label[self.size] = self.sizing.handles_labels()
         if hasattr(self, 'stripes_facets'):
             handle_label[STR['stripes']] = self.stripes_facets.handles_labels()
+        smoothers = {
+            label: Line2D(
+                xdata=[], ydata=[], color=plot.color, **KW.FIT_LINE_HANDLE)
+            for plot in self._plots
+            if (label := getattr(plot, 'legend_label', None)) is not None}
+        if smoothers:
+            handle_label[STR['smoothing']] = (
+                tuple(smoothers.values()), tuple(smoothers.keys()))
         return handle_label
 
     def _check_current_data_(self) -> bool: