wizata-dsapi 2.0.0.dev27__tar.gz → 2.0.0.dev29__tar.gz

{wizata_dsapi-2.0.0.dev27/wizata_dsapi.egg-info → wizata_dsapi-2.0.0.dev29}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.0.0.dev27
+Version: 2.0.0.dev29
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

{wizata_dsapi-2.0.0.dev27 → wizata_dsapi-2.0.0.dev29}/wizata_dsapi/plots/__init__.py

@@ -1,2 +1,2 @@
-from .common import ts_chart, confusion_matrix, r_squared, anomalies_chart, parallel_coordinates, data_table, setpoint_recommendation, feature_importance
+from .common import ts_chart, confusion_matrix, r_squared, anomalies_chart, parallel_coordinates, data_table, setpoint_recommendation, feature_importance, process_variability
 from . import theme

{wizata_dsapi-2.0.0.dev27 → wizata_dsapi-2.0.0.dev29}/wizata_dsapi/plots/common.py

@@ -6,13 +6,60 @@ import plotly.graph_objects as go
 import plotly.express as px
 import sklearn.metrics
 
+from plotly.subplots import make_subplots
+
 from .theme import (
-    apply_theme, SERIES_COLORS, ANOMALY_COLOR, TEXT_MUTED, WHITE,
+    apply_theme, SERIES_COLORS, ANOMALY_COLOR, MAIN_COLOR, POSITIVE_COLOR,
+    TEXT_MUTED, WHITE,
     TABLE_HEADER_BG, TABLE_HEADER_TEXT, TABLE_CELL_BG, TABLE_CELL_TEXT,
     TABLE_LINE_COLOR, FONT_FAMILY, FONT_SIZE,
+    COLUMN_TYPE_TELEMETRY, COLUMN_TYPE_SETPOINT, COLUMN_TYPE_RECOMMENDATION,
+    COLUMN_TYPE_TARGET, COLUMN_TYPE_CALCULATED, COLUMN_TYPES_ORDER,
 )
 
 
+def _classify_columns(df, context):
+    """Classify each dataframe column by its role in the pipeline.
+
+    Returns a dict of {col_name: {"type": str, "tag": str, "label": str, "color": str}}.
+    Type ordering: telemetry < setpoint < recommendation < calculated < target.
+    """
+    datapoints = context.datapoints or {}
+    target = context.properties.get("target_feat") if context.properties else None
+
+    # Also check models for target_feat if not in properties
+    if target is None and hasattr(context, "models") and context.models:
+        for model in context.models.values():
+            if hasattr(model, "has_target_feat") and model.has_target_feat:
+                target_candidates = getattr(model, "target_feat", None)
+                if target_candidates:
+                    target = target_candidates if isinstance(target_candidates, str) else target_candidates[0]
+                    break
+
+    classification = {}
+    for col in df.select_dtypes(include="number").columns:
+        if col == target:
+            classification[col] = {**COLUMN_TYPE_TARGET, "type": "target"}
+        elif isinstance(col, str) and col.endswith("_recommended"):
+            classification[col] = {**COLUMN_TYPE_RECOMMENDATION, "type": "recommendation"}
+        elif col in datapoints:
+            dp = datapoints[col]
+            if dp.business_type == wizata_dsapi.BusinessType.SET_POINTS:
+                classification[col] = {**COLUMN_TYPE_SETPOINT, "type": "setpoint"}
+            else:
+                classification[col] = {**COLUMN_TYPE_TELEMETRY, "type": "telemetry"}
+        else:
+            classification[col] = {**COLUMN_TYPE_CALCULATED, "type": "calculated"}
+
+    return classification
+
+
+def _sort_columns_by_type(columns, classification):
+    """Sort columns following COLUMN_TYPES_ORDER: telemetry, setpoint, recommendation, calculated, target."""
+    order_map = {t: i for i, t in enumerate(COLUMN_TYPES_ORDER)}
+    return sorted(columns, key=lambda c: order_map.get(classification.get(c, {}).get("type", "calculated"), 3))
+
+
 def check_single_column_and_target_feat(context: wizata_dsapi.Context):
     """
     check_single_column_and_target_feat
@@ -221,14 +268,12 @@ def parallel_coordinates(context: wizata_dsapi.Context):
 
 
 def setpoint_recommendation(context: wizata_dsapi.Context):
-    """Compare current vs recommended setpoint values as a Wizata-themed table.
-
-    Auto-pairs columns: for every column ending in '_recommended', looks for a matching column
-    with the same name minus the suffix. Validates that the base column corresponds to a datapoint
-    with BusinessType.SET_POINTS via context.datapoints (defense against accidental pairings).
-    Uses the **last row** of the dataframe for current and recommended values (most recent state).
+    """Compare current vs recommended setpoint values as a grouped bar chart with a summary table.
 
-    Output columns: Setpoint | Current | Recommended | Δ | Δ (%)
+    Auto-pairs columns ending in '_recommended' with the matching setpoint column, validated via
+    context.datapoints BusinessType.SET_POINTS. Uses the last row (most recent state). The top half
+    shows a horizontal grouped bar chart (Current vs Recommended) with type-colored labels; the
+    bottom half is a summary table with Setpoint | Current | Recommended | delta | delta (%).
     """
     df = context.dataframe
     datapoints = context.datapoints or {}
@@ -244,8 +289,6 @@ def setpoint_recommendation(context: wizata_dsapi.Context):
         base = col[: -len(suffix)]
         if base not in df.columns:
             continue
-        # Safety check: only pair if the base column is a declared setpoint datapoint.
-        # If datapoints are not populated (e.g. local test), fall back to pairing by name.
         if datapoints:
             dp = datapoints.get(base)
             if dp is None or dp.business_type != wizata_dsapi.BusinessType.SET_POINTS:
@@ -258,32 +301,64 @@ def setpoint_recommendation(context: wizata_dsapi.Context):
         )
 
     last = df.iloc[-1]
-    rows = []
+    names, currents, recommendeds, deltas, pcts = [], [], [], [], []
     for base, rec in pairs:
-        current = last[base]
-        recommended = last[rec]
+        current = float(last[base])
+        recommended = float(last[rec])
         delta = recommended - current
         pct = (delta / current * 100.0) if current not in (0, 0.0) and not pd.isna(current) else float("nan")
-        rows.append({
-            "Setpoint": base,
-            "Current": current,
-            "Recommended": recommended,
-            "Δ": delta,
-            "Δ (%)": pct,
-        })
-
-    out = pd.DataFrame(rows)
-
-    # Formatting — round numerics for readability
-    for col in ("Current", "Recommended", "Δ", "Δ (%)"):
-        out[col] = out[col].apply(lambda v: "—" if pd.isna(v) else f"{v:.3f}")
+        names.append(base)
+        currents.append(current)
+        recommendeds.append(recommended)
+        deltas.append(delta)
+        pcts.append(pct)
+
+    # ── Build combined figure: bar chart (top) + table (bottom) ──────────
+    fig = make_subplots(
+        rows=2, cols=1,
+        specs=[[{"type": "xy"}], [{"type": "domain"}]],
+        row_heights=[0.55, 0.45],
+        vertical_spacing=0.08,
+    )
 
-    n_rows = len(out)
+    # Grouped horizontal bars
+    fig.add_trace(go.Bar(
+        y=names,
+        x=recommendeds,
+        orientation="h",
+        name="Recommended Value",
+        marker_color=POSITIVE_COLOR,
+        text=[f"{v:.2f}" for v in recommendeds],
+        textposition="inside",
+        insidetextanchor="start",
+        textfont=dict(color=WHITE, size=FONT_SIZE),
+    ), row=1, col=1)
+
+    fig.add_trace(go.Bar(
+        y=names,
+        x=currents,
+        orientation="h",
+        name="Current Value",
+        marker_color=MAIN_COLOR,
+        text=[f"{v:.2f}" for v in currents],
+        textposition="inside",
+        insidetextanchor="start",
+        textfont=dict(color=WHITE, size=FONT_SIZE),
+    ), row=1, col=1)
+
+    fig.update_layout(barmode="group")
+    fig.update_xaxes(title_text="Values", row=1, col=1)
+    fig.update_yaxes(title_text="Setpoints", row=1, col=1)
+
+    # Summary table
+    fmt = lambda v: "—" if pd.isna(v) else f"{v:.3f}"
+    n_rows = len(names)
     cell_bg = [TABLE_CELL_BG[i % 2] for i in range(n_rows)]
 
-    fig = go.Figure(data=[go.Table(
+    fig.add_trace(go.Table(
         header=dict(
-            values=[f"<b>{c}</b>" for c in out.columns],
+            values=["<b>Setpoint</b>", "<b>Current</b>", "<b>Recommended</b>",
+                    "<b>\u0394</b>", "<b>\u0394 (%)</b>"],
             fill_color=TABLE_HEADER_BG,
             font=dict(family=FONT_FAMILY, size=FONT_SIZE, color=TABLE_HEADER_TEXT),
             align="left",
@@ -291,16 +366,25 @@ def setpoint_recommendation(context: wizata_dsapi.Context):
             height=32,
         ),
         cells=dict(
-            values=[out[c].tolist() for c in out.columns],
+            values=[
+                names,
+                [fmt(v) for v in currents],
+                [fmt(v) for v in recommendeds],
+                [fmt(v) for v in deltas],
+                [fmt(v) for v in pcts],
+            ],
             fill_color=[cell_bg],
             font=dict(family=FONT_FAMILY, size=FONT_SIZE, color=TABLE_CELL_TEXT),
             align="left",
             line_color=TABLE_LINE_COLOR,
             height=28,
         ),
-    )])
+    ), row=2, col=1)
 
-    fig.update_layout(margin=dict(l=0, r=0, t=0, b=0))
+    fig.update_layout(
+        title="Actual vs Recommended Values",
+        legend=dict(orientation="h", y=1.02, x=0.5, xanchor="center"),
+    )
     apply_theme(fig)
 
     context.set_plot(figure=fig, name="setpoint_recommendation")
@@ -361,6 +445,97 @@ def feature_importance(context: wizata_dsapi.Context):
     context.set_plot(figure=fig, name="feature_importance")
 
 
+def process_variability(context: wizata_dsapi.Context):
+    """Parallel coordinates plot showing process configurations variability, colored by a quality
+    outcome. Columns are ordered by type: telemetry, setpoints, recommendations, calculated,
+    with the target/quality column last. Each axis label is prefixed with a type tag
+    ([T], [SP], [REC], [C], [Q]) for quick identification.
+
+    Column selection:
+      - color_by: property name of the quality column used for coloring (defaults to
+        context.properties['target_feat'] if set, otherwise the last numeric column).
+      - color_reverse: set to true (default) when a LOWER color_by value is better
+        (e.g. residual_co2) — low values will be green. Set to false when higher is better
+        (e.g. 'good_bottles') — high values will be green.
+    """
+    df = context.dataframe
+    if df is None or len(df) == 0:
+        raise ValueError("process_variability: dataframe is empty")
+
+    numeric_cols = df.select_dtypes(include="number").columns.tolist()
+    if len(numeric_cols) < 2:
+        raise ValueError("process_variability: need at least 2 numeric columns")
+
+    # Classify and order columns by type
+    classification = _classify_columns(df, context)
+    ordered_cols = _sort_columns_by_type(
+        [c for c in numeric_cols if c in classification],
+        classification
+    )
+
+    # Resolve color column
+    color_by = context.properties.get("color_by")
+    if color_by is None:
+        color_by = context.properties.get("target_feat")
+    if color_by is None:
+        color_by = ordered_cols[-1] if ordered_cols else numeric_cols[-1]
+    if color_by not in df.columns:
+        raise ValueError(f"process_variability: color_by column '{color_by}' not found in dataframe")
+
+    color_reverse = context.properties.get("color_reverse", True)
+    if isinstance(color_reverse, str):
+        color_reverse = color_reverse.lower() not in ("false", "0", "no")
+
+    # Build dimensions with type-tagged labels, in order
+    dimensions = []
+    for col in ordered_cols:
+        col_vals = df[col].dropna()
+        if col_vals.empty:
+            continue
+        info = classification[col]
+        tagged_label = f"[{info['tag']}] {col}"
+        dimensions.append(dict(
+            label=tagged_label,
+            values=df[col].values,
+            range=[float(col_vals.min()), float(col_vals.max())],
+        ))
+
+    # Colorscale: red → yellow → green (reversed if lower is better)
+    if color_reverse:
+        colorscale = [[0, POSITIVE_COLOR], [0.5, "#FDDD60"], [1, "#FF6E76"]]
+    else:
+        colorscale = [[0, "#FF6E76"], [0.5, "#FDDD60"], [1, POSITIVE_COLOR]]
+
+    fig = go.Figure(data=go.Parcoords(
+        line=dict(
+            color=df[color_by].values,
+            colorscale=colorscale,
+            showscale=True,
+            colorbar=dict(title=color_by),
+        ),
+        dimensions=dimensions,
+    ))
+
+    # Add a legend-like annotation for the type tags
+    type_legend = "  ".join(
+        f"[{t['tag']}] {t['label']}"
+        for t in [COLUMN_TYPE_TELEMETRY, COLUMN_TYPE_SETPOINT, COLUMN_TYPE_RECOMMENDATION,
+                  COLUMN_TYPE_CALCULATED, COLUMN_TYPE_TARGET]
+    )
+    fig.update_layout(
+        title=dict(text="Configurations Variability"),
+        annotations=[dict(
+            text=type_legend,
+            xref="paper", yref="paper", x=0, y=-0.08,
+            showarrow=False,
+            font=dict(size=10, color=TEXT_MUTED),
+        )],
+    )
+    apply_theme(fig)
+
+    context.set_plot(figure=fig, name="process_variability")
+
+
 def data_table(context: wizata_dsapi.Context):
     """Render the dataframe as a styled table with Wizata theme colors."""
     df = context.dataframe.copy()

{wizata_dsapi-2.0.0.dev27 → wizata_dsapi-2.0.0.dev29}/wizata_dsapi/plots/theme.py

@@ -53,6 +53,16 @@ TABLE_CELL_BG = [TERTIARY, FOURTH]
 TABLE_CELL_TEXT = TEXT_MUTED
 TABLE_LINE_COLOR = "rgba(255,255,255,0.12)"
 
+# -- Column type classification -----------------------------------------------
+# Used by plots to visually distinguish column roles in the process pipeline.
+COLUMN_TYPE_TELEMETRY = {"tag": "T", "label": "Telemetry", "color": "#4992FF"}
+COLUMN_TYPE_SETPOINT = {"tag": "SP", "label": "Setpoint", "color": "#E64600"}
+COLUMN_TYPE_RECOMMENDATION = {"tag": "REC", "label": "Recommendation", "color": "#7CFFB2"}
+COLUMN_TYPE_TARGET = {"tag": "Q", "label": "Target / Quality", "color": "#FDDD60"}
+COLUMN_TYPE_CALCULATED = {"tag": "C", "label": "Calculated", "color": "#9E7CFF"}
+
+COLUMN_TYPES_ORDER = ["telemetry", "setpoint", "recommendation", "calculated", "target"]
+
 # -- Font ---------------------------------------------------------------------
 FONT_FAMILY = "Inter, -apple-system, BlinkMacSystemFont, sans-serif"
 FONT_SIZE = 12

wizata_dsapi-2.0.0.dev29/wizata_dsapi/version.py

@@ -0,0 +1 @@
+__version__ = "2.0.0.dev29"

{wizata_dsapi-2.0.0.dev27 → wizata_dsapi-2.0.0.dev29/wizata_dsapi.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: wizata_dsapi
-Version: 2.0.0.dev27
+Version: 2.0.0.dev29
 Summary: Wizata Data Science Toolkit
 Author: Wizata S.A.
 Author-email: info@wizata.com

wizata_dsapi-2.0.0.dev27/wizata_dsapi/version.py

@@ -1 +0,0 @@
-__version__ = "2.0.0.dev27"