From a581bec93179beb125ce183eff32894f54604b25 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 13:34:21 +0100 Subject: [PATCH 01/13] fix(explainer): keep the palette and earlier overrides in define_style --- shapash/explainer/smart_explainer.py | 41 +++++++++++------ shapash/style/style_utils.py | 33 +++++++++++++ .../explainer/test_smart_explainer.py | 46 +++++++++++++++++++ tests/unit_tests/style/test_style_utils.py | 27 +++++++++++ 4 files changed, 134 insertions(+), 13 deletions(-) diff --git a/shapash/explainer/smart_explainer.py b/shapash/explainer/smart_explainer.py index 1f52933b..f5225c26 100644 --- a/shapash/explainer/smart_explainer.py +++ b/shapash/explainer/smart_explainer.py @@ -2,7 +2,6 @@ from __future__ import annotations -import copy import logging from pathlib import Path from typing import TYPE_CHECKING, Any, cast @@ -13,7 +12,7 @@ import shapash.explainer.smart_predictor from shapash.backend import BaseBackend -from shapash.style.style_utils import colors_loading, select_palette +from shapash.style.style_utils import colors_loading, merge_palette, select_palette from shapash.utils.custom_thread import CustomThread from shapash.utils.drift import SchemaDriftConfig, compute_schema_distribution, resolve_schema_drift_config from shapash.utils.io import load_pickle, save_pickle @@ -118,8 +117,8 @@ class SmartExplainer: palette_name : str, optional Name of the color palette used for visualizations (see the `style` folder for options). colors_dict : dict, optional - Dictionary containing the full color palette configuration. - Can be used to override default plot colors. + Colors overriding those of ``palette_name``, with the same keys as the palette. + A nested mapping such as ``featureimp_bar`` can be given partially. **backend_kwargs : dict Additional keyword arguments passed to the backend. @@ -227,9 +226,7 @@ def __init__( title_story = title_story if title_story is not None else "" self.title_story = title_story self.palette_name = palette_name if palette_name else "default" - self.colors_dict = copy.deepcopy(select_palette(colors_loading(), self.palette_name)) - if colors_dict is not None: - self.colors_dict.update(colors_dict) + self.colors_dict = merge_palette(select_palette(colors_loading(), self.palette_name), colors_dict) self.explainer = Explainer( model=model, @@ -326,14 +323,32 @@ def compile( ) def define_style(self, palette_name: str | None = None, colors_dict: dict[str, Any] | None = None) -> None: - """Set the color set to use in plots.""" + """ + Change the colors used in plots. + + Parameters + ---------- + palette_name : str, optional + Name of the palette to switch to. Switching palette discards the colors + overridden earlier, in the constructor or in a previous call. + colors_dict : dict[str, Any], optional + Colors to override, merged on top of the palette and of the overrides already + in place. A nested mapping such as ``featureimp_bar`` can be given partially. + + Raises + ------ + ValueError + If neither ``palette_name`` nor ``colors_dict`` is given, or if the palette + does not exist. + """ if palette_name is None and colors_dict is None: raise ValueError("At least one of palette_name or colors_dict parameters must be defined") - new_palette_name = palette_name or self.palette_name - new_colors_dict = copy.deepcopy(select_palette(colors_loading(), new_palette_name)) - if colors_dict is not None: - new_colors_dict.update(colors_dict) - self.colors_dict.update(new_colors_dict) + if palette_name is not None: + base = select_palette(colors_loading(), palette_name) + self.palette_name = palette_name + else: + base = self.colors_dict + self.colors_dict = merge_palette(base, colors_dict) self.plot.define_style_attributes(colors_dict=self.colors_dict) def add( diff --git a/shapash/style/style_utils.py b/shapash/style/style_utils.py index 2a8752af..73da0fe4 100644 --- a/shapash/style/style_utils.py +++ b/shapash/style/style_utils.py @@ -1,5 +1,6 @@ """functions for loading and manipulating colors.""" +import copy import json import os from dataclasses import dataclass @@ -69,6 +70,38 @@ def select_palette(colors_dic: dict[str, Any], palette_name: str) -> dict[str, A return colors_dic[palette_name] +def merge_palette(palette: dict[str, Any], overrides: dict[str, Any] | None) -> dict[str, Any]: + """ + Return a copy of a palette with color overrides merged on top. + + A nested mapping such as ``featureimp_bar`` is merged key by key, so overriding one of its + colors keeps the others. Any other value, a list of colors included, is replaced whole. + Inside a nested mapping whose keys are strings, an override key is matched as a string, + so ``{1: "red"}`` and ``{"1": "red"}`` override the same color. + + Parameters + ---------- + palette : dict[str, Any] + Colors of one palette. It is not modified. + overrides : dict[str, Any] or None + Colors to set, with the same keys as the palette. + + Returns + ------- + dict[str, Any] + A new palette with the overrides applied. + """ + merged = copy.deepcopy(palette) + for key, value in (overrides or {}).items(): + base = merged.get(key) + if isinstance(base, dict) and isinstance(value, dict): + str_keys = all(isinstance(k, str) for k in base) + base.update({(str(k) if str_keys else k): copy.deepcopy(v) for k, v in value.items()}) + else: + merged[key] = copy.deepcopy(value) + return merged + + def convert_str_color_to_plt_format(txt: str) -> list[float]: """ Converts an rgb string format to a tuple of float (used by matplotlib format). diff --git a/tests/unit_tests/explainer/test_smart_explainer.py b/tests/unit_tests/explainer/test_smart_explainer.py index 772af211..9510a922 100644 --- a/tests/unit_tests/explainer/test_smart_explainer.py +++ b/tests/unit_tests/explainer/test_smart_explainer.py @@ -26,6 +26,7 @@ from shapash.explainer.smart_state import SmartState from shapash.utils.check import check_model from shapash.report.blocks import ReportBlockMixin +from shapash.style.style_utils import colors_loading def init_sme_to_pickle_test(): @@ -975,6 +976,51 @@ def test_define_style_2(self): with self.assertRaisesRegex(ValueError, "At least one of palette_name or colors_dict parameters must be defined"): xpl.define_style() + def test_define_style_override_keeps_palette(self): + """An override-only call keeps the palette chosen earlier.""" + palettes = colors_loading() + xpl = SmartExplainer(self.model) + xpl.define_style(palette_name="blues") + xpl.define_style(colors_dict={"title_color": "rgb(1, 2, 3)"}) + + assert xpl.palette_name == "blues" + assert xpl.colors_dict["webapp_title"] == palettes["blues"]["webapp_title"] + assert xpl.colors_dict["title_color"] == "rgb(1, 2, 3)" + assert xpl.plot._style_dict["dict_title"]["font"]["color"] == "rgb(1, 2, 3)" + + def test_define_style_overrides_accumulate(self): + """Successive override-only calls keep the earlier overrides, constructor ones included.""" + xpl = SmartExplainer(self.model, colors_dict={"title_color": "rgb(1, 2, 3)"}) + xpl.define_style(colors_dict={"axis_color": "rgb(4, 5, 6)"}) + + assert xpl.colors_dict["title_color"] == "rgb(1, 2, 3)" + assert xpl.colors_dict["axis_color"] == "rgb(4, 5, 6)" + + def test_define_style_palette_switch_resets_overrides(self): + """Switching palette discards earlier overrides and applies the ones given with it.""" + palettes = colors_loading() + xpl = SmartExplainer(self.model, colors_dict={"title_color": "rgb(1, 2, 3)"}) + xpl.define_style(palette_name="blues", colors_dict={"axis_color": "rgb(4, 5, 6)"}) + + assert xpl.colors_dict["title_color"] == palettes["blues"]["title_color"] + assert xpl.colors_dict["axis_color"] == "rgb(4, 5, 6)" + assert xpl.colors_dict["webapp_title"] == palettes["blues"]["webapp_title"] + + def test_define_style_unknown_palette_keeps_state(self): + """An unknown palette raises and leaves the current palette in place.""" + xpl = SmartExplainer(self.model) + with self.assertRaisesRegex(ValueError, "Palette unknown not found"): + xpl.define_style(palette_name="unknown") + assert xpl.palette_name == "default" + + def test_partial_nested_colors_dict(self): + """A partial nested override in the constructor keeps the palette's other colors.""" + default = colors_loading()["default"] + xpl = SmartExplainer(self.model, colors_dict={"featureimp_bar": {"1": "rgb(1, 2, 3)"}}) + + assert xpl.colors_dict["featureimp_bar"] == {**default["featureimp_bar"], "1": "rgb(1, 2, 3)"} + assert xpl.plot._style_dict["dict_featimp_colors"][1]["color"] == "rgb(1, 2, 3)" + def test_check_x_y_attributes_1(self): """Unit test check_x_y_attributes with existing and missing attributes.""" xpl = SmartExplainer(self.model) diff --git a/tests/unit_tests/style/test_style_utils.py b/tests/unit_tests/style/test_style_utils.py index 35bfd55a..1e5059de 100644 --- a/tests/unit_tests/style/test_style_utils.py +++ b/tests/unit_tests/style/test_style_utils.py @@ -9,6 +9,7 @@ convert_str_color_to_plt_format, define_style, get_pyplot_color, + merge_palette, resolve_nlp_theme, select_palette, ) @@ -119,3 +120,29 @@ def test_resolve_nlp_theme(self): overridden = resolve_nlp_theme(colors_dict={"nlp_xpl_positive": "rgb(1, 2, 3)"}) assert overridden.xpl_positive == "rgb(1, 2, 3)" assert overridden.xpl_negative == default_palette["nlp_xpl_negative"] + + def test_merge_palette_nested_partial_override(self): + """A partial nested override keeps the other colors and leaves the palette untouched.""" + palette = {"bar": {"1": "a", "2": "b"}, "scale": ["x", "y"], "title": "t"} + merged = merge_palette(palette, {"bar": {"1": "red"}, "scale": ["z"], "title": "u"}) + assert merged == {"bar": {"1": "red", "2": "b"}, "scale": ["z"], "title": "u"} + assert palette == {"bar": {"1": "a", "2": "b"}, "scale": ["x", "y"], "title": "t"} + + def test_merge_palette_int_keys_match_string_keys(self): + """An int key overrides the palette's string key instead of adding a second entry.""" + merged = merge_palette({"bar": {"1": "a", "2": "b"}}, {"bar": {1: "red"}}) + assert merged == {"bar": {"1": "red", "2": "b"}} + + def test_merge_palette_without_overrides_returns_a_copy(self): + """No override returns an independent copy of the palette.""" + palette = {"bar": {"1": "a"}} + merged = merge_palette(palette, None) + merged["bar"]["1"] = "red" + assert palette == {"bar": {"1": "a"}} + + def test_define_style_accepts_partial_nested_override(self): + """define_style no longer fails on a palette with a partially overridden nested mapping.""" + palette = merge_palette(select_palette(colors_loading(), "default"), {"featureimp_bar": {"1": "rgb(1, 2, 3)"}}) + style = define_style(palette) + assert style["dict_featimp_colors"][1]["color"] == "rgb(1, 2, 3)" + assert style["dict_featimp_colors"][2]["color"] == colors_loading()["default"]["featureimp_bar"]["2"] From 4bdee02eacd1eb2bf2ebcc00fb08210c33d68e93 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 13:34:52 +0100 Subject: [PATCH 02/13] fix(report): use the resolved plot style for the confusion matrix --- shapash/report/blocks.py | 2 +- tests/unit_tests/report/test_report_generation.py | 11 +++++++++++ 2 files changed, 12 insertions(+), 1 deletion(-) diff --git a/shapash/report/blocks.py b/shapash/report/blocks.py index c8b61331..e62bf431 100644 --- a/shapash/report/blocks.py +++ b/shapash/report/blocks.py @@ -1023,7 +1023,7 @@ def block_confusion_matrix(self, title: str | None = "") -> BlockContent: raise ValueError("confusion_matrix block requires y_test and predicted values from the explainer.") y_test = cast(TargetValues, self.y_test) y_pred = cast(TargetValues, self.y_pred) - fig = plot_confusion_matrix(y_true=y_test, y_pred=y_pred, colors_dict=smart_explainer.colors_dict) + fig = plot_confusion_matrix(y_true=y_test, y_pred=y_pred, colors_dict=smart_explainer.plot._style_dict) if title is None: return "Confusion matrix", [fig] return title, [fig] diff --git a/tests/unit_tests/report/test_report_generation.py b/tests/unit_tests/report/test_report_generation.py index 78264ebe..662d6933 100644 --- a/tests/unit_tests/report/test_report_generation.py +++ b/tests/unit_tests/report/test_report_generation.py @@ -657,6 +657,17 @@ def test_block_confusion_lift_and_univariate_render(self): self.assertIsInstance(univariate_result.objects[1], pn.widgets.Select) self.assertEqual(type(univariate_result.objects[2]).__name__, "ParamFunction") + def test_block_confusion_matrix_uses_explainer_style(self): + """The report's confusion matrix gets the plotter's resolved style, like xpl.plot does.""" + runtime = _build_runtime() + smart_explainer = runtime._require_smart_explainer("confusion_matrix") + fake_fig = go.Figure(go.Scatter(x=[0, 1], y=[1, 0])) + + with patch("shapash.report.blocks.plot_confusion_matrix", return_value=fake_fig) as mock_cm: + runtime.block_confusion_matrix(title="CM") + + assert mock_cm.call_args.kwargs["colors_dict"] is smart_explainer.plot._style_dict + def test_smart_explainer_required(self): rbm = ReportBlockMixin() with pytest.raises(ValueError): From f756a6bc93568fb973c21793815c0e634542e106 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 13:35:09 +0100 Subject: [PATCH 03/13] fix(plots): use palette colours in distribution plots instead of random ones --- shapash/plots/plot_univariate.py | 43 +++++++++++++++++++++------ tests/unit_tests/report/test_plots.py | 34 +++++++++++++++++++++ 2 files changed, 68 insertions(+), 9 deletions(-) diff --git a/shapash/plots/plot_univariate.py b/shapash/plots/plot_univariate.py index 0ac9497f..51076fe9 100644 --- a/shapash/plots/plot_univariate.py +++ b/shapash/plots/plot_univariate.py @@ -8,10 +8,35 @@ from scipy.stats import gaussian_kde from shapash.report.common import VarType, series_dtype -from shapash.style.style_utils import define_style, get_palette, random_color +from shapash.style.style_utils import define_style, get_palette from shapash.utils.utils import adjust_title_height, compute_digit_number +def _series_color(style_dict: dict[str, Any], key: Any, index: int) -> str: + """ + Color of one curve or bar group of a distribution plot. + + Parameters + ---------- + style_dict : dict[str, Any] + Resolved style, possibly extended with explicit colors keyed by level or column name. + key : Any + Level of the hue column, or the column name when there is no hue. + index : int + Position of the series, used to pick a color from the palette's discrete colors. + + Returns + ------- + str + The explicit color given for ``key``, else the palette's discrete colors in turn. + """ + color = style_dict.get(key) + if isinstance(color, str): + return color + discrete_colors = style_dict["interactions_discrete_colors"] + return discrete_colors[index % len(discrete_colors)] + + def plot_distribution( df_all: pd.DataFrame, col: str, @@ -162,7 +187,7 @@ def plot_continuous_distribution( """ if colors_dict: style_dict = {} - keys = ["dict_title", "init_confusion_matrix_colorscale", "dict_xaxis", "dict_yaxis"] + keys = ["dict_title", "dict_xaxis", "dict_yaxis", "interactions_discrete_colors"] if any(key not in colors_dict for key in keys): style_dict = define_style(get_palette(palette_name)) style_dict.update(colors_dict) @@ -197,7 +222,7 @@ def plot_continuous_distribution( filtered_data[hue] = filtered_data[hue].where(filtered_data[hue].isin(top_categories), other="Other") unique_hues = filtered_data[hue].unique() - for level in unique_hues: + for i, level in enumerate(unique_hues): subset = filtered_data[filtered_data[hue] == level] if len(subset) < 5: warnings.warn( # noqa: B028 @@ -215,7 +240,7 @@ def plot_continuous_distribution( for x, y in zip(x_values, y_values, strict=False) ] - color = style_dict.get(level, random_color()) + color = _series_color(style_dict, level, i) fig.add_trace( go.Scatter( @@ -246,7 +271,7 @@ def plot_continuous_distribution( for x, y in zip(x_values, y_values, strict=False) ] - color = style_dict.get(col, random_color()) + color = _series_color(style_dict, col, 0) fig.add_trace( go.Scatter( @@ -345,7 +370,7 @@ def plot_categorical_distribution( df_all = df_all.copy() if colors_dict: style_dict = {} - keys = ["dict_title", "init_confusion_matrix_colorscale", "dict_xaxis", "dict_yaxis"] + keys = ["dict_title", "dict_xaxis", "dict_yaxis", "interactions_discrete_colors"] if any(key not in colors_dict for key in keys): style_dict = define_style(get_palette(palette_name)) style_dict.update(colors_dict) @@ -386,9 +411,9 @@ def plot_categorical_distribution( data = [] if hue: - for hue_val in hue_order: + for i, hue_val in enumerate(hue_order): subset = df_cat[df_cat[hue] == hue_val] - color = style_dict.get(hue_val, random_color()) + color = _series_color(style_dict, hue_val, i) customdata = subset.apply( lambda row, hue_val=hue_val: ( @@ -410,7 +435,7 @@ def plot_categorical_distribution( ) data.append(bar) else: - color = style_dict.get(col, random_color()) + color = _series_color(style_dict, col, 0) customdata = df_cat.apply( lambda row: ( diff --git a/tests/unit_tests/report/test_plots.py b/tests/unit_tests/report/test_plots.py index 8ddfa906..06a61523 100644 --- a/tests/unit_tests/report/test_plots.py +++ b/tests/unit_tests/report/test_plots.py @@ -12,6 +12,8 @@ from plotly import graph_objects as go +from shapash.style.style_utils import colors_loading + class TestPlots(unittest.TestCase): @patch("shapash.plots.plot_univariate.plot_continuous_distribution") @patch("shapash.plots.plot_univariate.plot_categorical_distribution") @@ -96,6 +98,38 @@ def test_plot_continuous_distribution_high_cardinality_with_colors_dict(self): assert min(trace.x[0] for trace in fig.data) == 2 assert max(trace.x[-1] for trace in fig.data) == 198 + def test_plot_continuous_distribution_uses_palette_colors(self): + """Without explicit colors, levels take the palette's discrete colors, the same on every call.""" + discrete = colors_loading()["default"]["interaction_discrete"] + df = pd.DataFrame({"int_data": np.arange(40), "data_train_test": ["train", "test"] * 20}) + + fig = plot_continuous_distribution(df, "int_data", hue="data_train_test") + again = plot_continuous_distribution(df, "int_data", hue="data_train_test") + + assert [trace.line.color for trace in fig.data] == discrete[:2] + assert [trace.line.color for trace in again.data] == discrete[:2] + + def test_plot_categorical_distribution_uses_palette_colors(self): + """Without explicit colors, bars take the palette's discrete colors, with or without hue.""" + discrete = colors_loading()["blues"]["interaction_discrete"] + df = pd.DataFrame({"int_data": [0, 0, 0, 1, 1, 0], "data_train_test": ["train"] * 4 + ["test"] * 2}) + + fig = plot_categorical_distribution(df, "int_data", "data_train_test", palette_name="blues") + no_hue = plot_categorical_distribution(df, "int_data", palette_name="blues") + + assert [trace.marker.color for trace in fig.data] == discrete[:2] + assert no_hue.data[0].marker.color == discrete[0] + + def test_plot_distribution_cycles_palette_colors(self): + """More levels than discrete colors reuse the colors in turn.""" + discrete = colors_loading()["default"]["interaction_discrete"] + levels = [f"l{i}" for i in range(len(discrete) + 1)] + df = pd.DataFrame({"int_data": [0, 1] * len(levels), "level": levels * 2}) + + fig = plot_categorical_distribution(df, "int_data", "level", nb_hue_max=len(levels)) + + assert fig.data[-1].marker.color == discrete[0] + def test_plot_categorical_distribution_1(self): df = pd.DataFrame( {"int_data": [0, 0, 0, 1, 1, 0], "data_train_test": ["train", "train", "train", "train", "test", "test"]} From 4c2fa1ca9981f2bb39529679dedbe984bfbfcf15 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 13:53:31 +0100 Subject: [PATCH 04/13] feat(style): accept hex codes, colour names and plotly scale names in colors_dict --- shapash/explainer/smart_explainer.py | 38 +++- shapash/style/style_utils.py | 207 +++++++++++++++++- .../explainer/test_smart_explainer.py | 8 +- .../explainer/test_smart_explainer_colors.py | 80 +++++++ .../report/test_report_generation.py | 2 +- tests/unit_tests/style/test_style_utils.py | 99 +++++++++ 6 files changed, 422 insertions(+), 12 deletions(-) create mode 100644 tests/unit_tests/explainer/test_smart_explainer_colors.py diff --git a/shapash/explainer/smart_explainer.py b/shapash/explainer/smart_explainer.py index f5225c26..67800aae 100644 --- a/shapash/explainer/smart_explainer.py +++ b/shapash/explainer/smart_explainer.py @@ -12,7 +12,7 @@ import shapash.explainer.smart_predictor from shapash.backend import BaseBackend -from shapash.style.style_utils import colors_loading, merge_palette, select_palette +from shapash.style.style_utils import colors_loading, merge_palette, normalize_colors, select_palette from shapash.utils.custom_thread import CustomThread from shapash.utils.drift import SchemaDriftConfig, compute_schema_distribution, resolve_schema_drift_config from shapash.utils.io import load_pickle, save_pickle @@ -118,7 +118,12 @@ class SmartExplainer: Name of the color palette used for visualizations (see the `style` folder for options). colors_dict : dict, optional Colors overriding those of ``palette_name``, with the same keys as the palette. - A nested mapping such as ``featureimp_bar`` can be given partially. + A nested mapping such as ``featureimp_bar`` can be given partially. Colors can be + ``rgb(...)``/``rgba(...)`` strings, hex codes or color names. A continuous scale + (``contrib_colorscale``, ``confusion_matrix_colorscale``, ``interaction_scale``, + ``feature_contributions_cumulative``) also accepts a plotly scale name such as + ``"RdBu"`` or ``"viridis_r"``, and a list of distinct colors (``interaction_discrete``, + ``compare_plot``) a plotly qualitative palette name such as ``"Set2"``. **backend_kwargs : dict Additional keyword arguments passed to the backend. @@ -226,7 +231,7 @@ def __init__( title_story = title_story if title_story is not None else "" self.title_story = title_story self.palette_name = palette_name if palette_name else "default" - self.colors_dict = merge_palette(select_palette(colors_loading(), self.palette_name), colors_dict) + self.colors_dict = self._resolve_colors(select_palette(colors_loading(), self.palette_name), colors_dict) self.explainer = Explainer( model=model, @@ -333,13 +338,13 @@ def define_style(self, palette_name: str | None = None, colors_dict: dict[str, A overridden earlier, in the constructor or in a previous call. colors_dict : dict[str, Any], optional Colors to override, merged on top of the palette and of the overrides already - in place. A nested mapping such as ``featureimp_bar`` can be given partially. + in place. Accepts the same values as the constructor's ``colors_dict``. Raises ------ ValueError - If neither ``palette_name`` nor ``colors_dict`` is given, or if the palette - does not exist. + If neither ``palette_name`` nor ``colors_dict`` is given, if the palette does + not exist, or if a color in ``colors_dict`` is not valid. """ if palette_name is None and colors_dict is None: raise ValueError("At least one of palette_name or colors_dict parameters must be defined") @@ -348,9 +353,28 @@ def define_style(self, palette_name: str | None = None, colors_dict: dict[str, A self.palette_name = palette_name else: base = self.colors_dict - self.colors_dict = merge_palette(base, colors_dict) + self.colors_dict = self._resolve_colors(base, colors_dict) self.plot.define_style_attributes(colors_dict=self.colors_dict) + @staticmethod + def _resolve_colors(base: dict[str, Any], colors_dict: dict[str, Any] | None) -> dict[str, Any]: + """ + Return ``base`` with the validated ``colors_dict`` overrides merged on top. + + Parameters + ---------- + base : dict[str, Any] + Colors the overrides apply to. + colors_dict : dict[str, Any] or None + Color overrides. + + Returns + ------- + dict[str, Any] + The resolved colors. + """ + return merge_palette(base, normalize_colors(colors_dict, base)) + def add( self, y_pred: pd.Series | pd.DataFrame | None = None, diff --git a/shapash/style/style_utils.py b/shapash/style/style_utils.py index 73da0fe4..a76f4e85 100644 --- a/shapash/style/style_utils.py +++ b/shapash/style/style_utils.py @@ -1,12 +1,18 @@ """functions for loading and manipulating colors.""" import copy +import difflib import json import os +import re +import warnings from dataclasses import dataclass from typing import Any import numpy as np +import plotly.colors as plotly_colors +from matplotlib.colors import to_rgba +from plotly.exceptions import PlotlyError from shapash.utils.utils import convert_string_to_int_keys @@ -102,6 +108,205 @@ def merge_palette(palette: dict[str, Any], overrides: dict[str, Any] | None) -> return merged +# Palette keys holding a continuous color scale: they also accept a plotly scale name. +CONTINUOUS_SCALE_KEYS = frozenset( + { + "contrib_colorscale", + "confusion_matrix_colorscale", + "interaction_scale", + "feature_contributions_cumulative", + "report_confusion_matrix", + } +) +# Palette keys holding a list of distinct colors: they also accept a plotly qualitative palette name. +DISCRETE_COLOR_KEYS = frozenset({"interaction_discrete", "compare_plot"}) +# Scales drawing signed values: a non-diverging scale hides the sign, so it draws a warning. +SIGNED_SCALE_KEYS = frozenset({"contrib_colorscale"}) + +_RGB_PATTERN = re.compile(r"^\s*rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)\s*$") + + +def _rgba_components(color: str) -> tuple[int, int, int, float | None]: + """Return the 0-255 components of a color and its opacity, ``None`` when opaque.""" + if not isinstance(color, str): + raise ValueError(f"{color!r} is not a valid color: expected a string.") + match = _RGB_PATTERN.match(color) + if match: + r, g, b = (round(float(component)) for component in match.groups()[:3]) + alpha = None if match.group(4) is None else float(match.group(4)) + if max(r, g, b) > 255 or (alpha is not None and alpha > 1): + raise ValueError(f"{color!r} is not a valid color: components must be in 0-255 and alpha in 0-1.") + return r, g, b, alpha + try: + red, green, blue, opacity = to_rgba(color) + except ValueError as exc: + raise ValueError( + f"{color!r} is not a valid color: use rgb(...), rgba(...), a hex code or a color name." + ) from exc + r, g, b = (round(component * 255) for component in (red, green, blue)) + return r, g, b, (None if opacity == 1 else opacity) + + +def to_rgb_string(color: str) -> str: + """ + Convert a color to the ``rgb(r, g, b)`` / ``rgba(r, g, b, a)`` format used by Shapash. + + Parameters + ---------- + color : str + An ``rgb(...)`` or ``rgba(...)`` string, a hex code (``#1f77b4``, ``#1f77b480``) or a + color name (``red``). + + Returns + ------- + str + ``rgb(r, g, b)`` for an opaque color, ``rgba(r, g, b, a)`` otherwise. + + Raises + ------ + ValueError + If ``color`` is not a valid color. + """ + r, g, b, alpha = _rgba_components(color) + if alpha is None: + return f"rgb({r}, {g}, {b})" + return f"rgba({r}, {g}, {b}, {alpha:g})" + + +def parse_rgb(color: str) -> tuple[int, int, int]: + """ + Return the red, green and blue components of a color, ignoring its opacity. + + Parameters + ---------- + color : str + Any color accepted by :func:`to_rgb_string`. + + Returns + ------- + tuple[int, int, int] + Components in 0-255. + + Raises + ------ + ValueError + If ``color`` is not a valid color. + """ + r, g, b, _ = _rgba_components(color) + return r, g, b + + +def _named_lists(module: Any) -> dict[str, list[str]]: + """Map the lowercased names of a plotly color module to their lists of colors.""" + return {name.lower(): value for name, value in vars(module).items() if isinstance(value, list)} + + +def _sample_named_scale(key: str, name: str, n_colors: int) -> list[str]: + """Sample the plotly scale *name* to *n_colors* colors for the palette entry *key*.""" + try: + colors = plotly_colors.sample_colorscale(name, n_colors) + except PlotlyError as exc: + raise ValueError(f"Invalid value for {key!r}: {name!r} is not a plotly color scale name.") from exc + if key in SIGNED_SCALE_KEYS and name.lower().removesuffix("_r") not in _named_lists(plotly_colors.diverging): + warnings.warn( + f"{name!r} is not a diverging scale: with it, {key!r} no longer shows whether a contribution " + "is positive or negative. A diverging scale such as 'RdBu' keeps the sign visible.", + UserWarning, + stacklevel=6, + ) + return [to_rgb_string(color) for color in colors] + + +def _named_discrete_colors(key: str, name: str) -> list[str]: + """Return the colors of the plotly qualitative palette *name* for the palette entry *key*.""" + colors = _named_lists(plotly_colors.qualitative).get(name.lower()) + if colors is None: + raise ValueError(f"Invalid value for {key!r}: {name!r} is not a plotly qualitative palette name.") + return [to_rgb_string(color) for color in colors] + + +def _normalize_entry(key: str, value: Any, default: Any) -> Any: + """Normalize the override *value* of the palette entry *key*, whose palette value is *default*.""" + try: + if isinstance(value, str): + if key in CONTINUOUS_SCALE_KEYS and isinstance(default, list): + return _sample_named_scale(key, value, len(default)) + if key in DISCRETE_COLOR_KEYS: + return _named_discrete_colors(key, value) + return to_rgb_string(value) + if isinstance(value, dict): + return {sub_key: to_rgb_string(color) for sub_key, color in value.items()} + if isinstance(value, list | tuple): + return [to_rgb_string(color) for color in value] + except ValueError as exc: + if str(exc).startswith("Invalid value for"): + raise + raise ValueError(f"Invalid value for {key!r}: {exc}") from exc + raise ValueError(f"Invalid value for {key!r}: expected a color, a list or a dict of colors, got {value!r}.") + + +def normalize_colors(colors_dict: dict[str, Any] | None, palette: dict[str, Any]) -> dict[str, Any]: + """ + Validate color overrides and convert them to the format the plots expect. + + Every color becomes an ``rgb(...)`` / ``rgba(...)`` string. A plotly scale name given for a + continuous scale (``contrib_colorscale``, ...) is sampled to as many colors as the palette + holds, and a plotly qualitative palette name given for a list of distinct colors + (``interaction_discrete``, ``compare_plot``) is replaced by its colors. + + Parameters + ---------- + colors_dict : dict[str, Any] or None + Color overrides, with the same keys as the palette. + palette : dict[str, Any] + The palette the overrides apply to. + + Returns + ------- + dict[str, Any] + The normalized overrides. + + Raises + ------ + ValueError + If a color, scale name or qualitative palette name is not valid. + + Warns + ----- + UserWarning + For a key the palette does not have, and for a non-diverging scale name given for + ``contrib_colorscale``. + """ + normalized = {} + for key, value in (colors_dict or {}).items(): + if key not in palette: + close = difflib.get_close_matches(key, palette, n=1) + hint = f" Did you mean {close[0]!r}?" if close else "" + warnings.warn(f"Unknown color key {key!r}: no plot uses it.{hint}", UserWarning, stacklevel=4) + normalized[key] = _normalize_entry(key, value, palette.get(key)) + return normalized + + +def resolve_colors(palette_name: str, colors_dict: dict[str, Any] | None = None) -> dict[str, Any]: + """ + Return the colors of a palette with validated overrides merged on top. + + Parameters + ---------- + palette_name : str + Name of a palette in ``colors.json``. + colors_dict : dict[str, Any], optional + Color overrides, see :func:`normalize_colors` for what each key accepts. + + Returns + ------- + dict[str, Any] + The resolved colors, every key of the palette included. + """ + palette = select_palette(colors_loading(), palette_name) + return merge_palette(palette, normalize_colors(colors_dict, palette)) + + def convert_str_color_to_plt_format(txt: str) -> list[float]: """ Converts an rgb string format to a tuple of float (used by matplotlib format). @@ -265,7 +470,7 @@ def resolve_nlp_theme(palette_name: str = "default", colors_dict: dict[str, str] ------- NlpTheme """ - palette = {**select_palette(colors_loading(), palette_name), **(colors_dict or {})} + palette = resolve_colors(palette_name, colors_dict) return NlpTheme( header_bkg=palette["webapp_bkg"], header_accent=palette["webapp_title"], diff --git a/tests/unit_tests/explainer/test_smart_explainer.py b/tests/unit_tests/explainer/test_smart_explainer.py index 9510a922..192ebe3c 100644 --- a/tests/unit_tests/explainer/test_smart_explainer.py +++ b/tests/unit_tests/explainer/test_smart_explainer.py @@ -14,6 +14,7 @@ import category_encoders as ce import numpy as np import pandas as pd +import pytest import shap from catboost import CatBoostClassifier, CatBoostRegressor from pandas.testing import assert_frame_equal @@ -963,11 +964,12 @@ def test_define_style_1(self): with patch("shapash.explainer.smart_explainer.colors_loading", return_value={"dummy": {}}), patch( "shapash.explainer.smart_explainer.select_palette", return_value={"color_1": "blue", "color_2": "red"} ): - xpl.define_style(palette_name="custom", colors_dict={"color_2": "green", "color_3": "black"}) + with pytest.warns(UserWarning, match="Unknown color key 'color_3'"): + xpl.define_style(palette_name="custom", colors_dict={"color_2": "green", "color_3": "black"}) assert xpl.colors_dict["color_1"] == "blue" - assert xpl.colors_dict["color_2"] == "green" - assert xpl.colors_dict["color_3"] == "black" + assert xpl.colors_dict["color_2"] == "rgb(0, 128, 0)" + assert xpl.colors_dict["color_3"] == "rgb(0, 0, 0)" xpl.plot.define_style_attributes.assert_called_once_with(colors_dict=xpl.colors_dict) def test_define_style_2(self): diff --git a/tests/unit_tests/explainer/test_smart_explainer_colors.py b/tests/unit_tests/explainer/test_smart_explainer_colors.py new file mode 100644 index 00000000..3a0e5679 --- /dev/null +++ b/tests/unit_tests/explainer/test_smart_explainer_colors.py @@ -0,0 +1,80 @@ +""" +End-to-end tests of color customization: overrides given to SmartExplainer reach the plots. +""" + +import numpy as np +import pandas as pd +import pytest +from sklearn.ensemble import RandomForestClassifier + +from shapash import SmartExplainer + + +@pytest.fixture(scope="module") +def data(): + rng = np.random.default_rng(0) + x = pd.DataFrame(rng.normal(size=(60, 4)), columns=list("abcd")) + y = pd.Series((x["a"] + x["b"] > 0).astype(int), name="y") + model = RandomForestClassifier(n_estimators=5, random_state=0).fit(x, y) + contributions = pd.DataFrame(rng.normal(size=x.shape), columns=x.columns, index=x.index) + return model, x, y, contributions + + +def _explainer(data, **kwargs): + model, x, y, contributions = data + xpl = SmartExplainer(model=model, **kwargs) + xpl.compile(x=x, contributions=[-contributions, contributions], y_target=y) + return xpl + + +def test_named_contribution_scale_reaches_plots(data): + """A diverging scale name drives the contribution and correlation plots.""" + xpl = _explainer(data, colors_dict={"contrib_colorscale": "RdBu"}) + scale = xpl.colors_dict["contrib_colorscale"] + + contribution = xpl.plot.contribution_plot("a") + correlations = xpl.plot.correlations_plot() + + assert scale[0] == "rgb(103, 0, 31)" + assert contribution.layout.coloraxis.colorscale[0][1] == scale[0] + assert correlations.layout.coloraxis.colorscale[-1][1] in scale + + +def test_named_confusion_scale_reaches_plot(data): + """A scale name drives the confusion matrix.""" + xpl = _explainer(data, colors_dict={"confusion_matrix_colorscale": "viridis"}) + + fig = xpl.plot.confusion_matrix_plot() + + assert fig.data[0].colorscale[0][1] == "rgb(68, 1, 84)" + + +@pytest.mark.parametrize("colors", ["viridis", ["#000000", "#222222", "#444444", "#666666", "#888888", "#aaaaaa"]]) +def test_cumulative_importance_accepts_names_and_hex(data, colors): + """The matplotlib-based cumulative importance plot accepts a scale name and hex colors.""" + xpl = _explainer(data, colors_dict={"feature_contributions_cumulative": colors}) + + fig = xpl.plot.features_importance(mode="cumulative") + + assert fig is not None + + +def test_define_style_with_named_scale(data): + """define_style accepts the same values as the constructor.""" + xpl = _explainer(data) + + xpl.define_style(colors_dict={"interaction_scale": "viridis", "featureimp_bar": {"1": "#000000"}}) + + assert xpl.plot._style_dict["interactions_col_scale"] == ["rgb(68, 1, 84)", "rgb(34, 144, 140)", "rgb(253, 231, 37)"] + assert xpl.plot.features_importance().data[-1].marker.color[0] == "rgb(0, 0, 0)" + + +def test_invalid_color_raises_before_any_change(data): + """An invalid color raises and leaves the current colors in place.""" + xpl = _explainer(data) + before = xpl.colors_dict + + with pytest.raises(ValueError, match="Invalid value for 'title_color'"): + xpl.define_style(colors_dict={"title_color": "notacolor"}) + + assert xpl.colors_dict is before diff --git a/tests/unit_tests/report/test_report_generation.py b/tests/unit_tests/report/test_report_generation.py index 662d6933..8331ebad 100644 --- a/tests/unit_tests/report/test_report_generation.py +++ b/tests/unit_tests/report/test_report_generation.py @@ -96,7 +96,7 @@ def __init__(self): super().__init__( model=model, backend=_DummyBackend(model), features_dict={"age": "Age", "income": "Income"}, - colors_dict={"report_feature_distribution": {"train": "#f4c000", "test": "#2255aa"}, "default": "#2255aa"}, + colors_dict={"report_feature_distribution": {"train": "#f4c000", "test": "#2255aa"}}, ) self.plot = _DummyPlot() self.explainer.plot = self.plot diff --git a/tests/unit_tests/style/test_style_utils.py b/tests/unit_tests/style/test_style_utils.py index 1e5059de..c5c6be12 100644 --- a/tests/unit_tests/style/test_style_utils.py +++ b/tests/unit_tests/style/test_style_utils.py @@ -3,6 +3,9 @@ """ import re import unittest +import warnings + +import pytest from shapash.style.style_utils import ( colors_loading, @@ -10,8 +13,12 @@ define_style, get_pyplot_color, merge_palette, + normalize_colors, + parse_rgb, + resolve_colors, resolve_nlp_theme, select_palette, + to_rgb_string, ) @@ -146,3 +153,95 @@ def test_define_style_accepts_partial_nested_override(self): style = define_style(palette) assert style["dict_featimp_colors"][1]["color"] == "rgb(1, 2, 3)" assert style["dict_featimp_colors"][2]["color"] == colors_loading()["default"]["featureimp_bar"]["2"] + + def test_to_rgb_string_accepts_every_supported_format(self): + """rgb/rgba strings, hex codes and color names all come out in the rgb(...) format.""" + assert to_rgb_string("rgb(1,2,3)") == "rgb(1, 2, 3)" + assert to_rgb_string("rgba(1, 2, 3, 0.80)") == "rgba(1, 2, 3, 0.8)" + assert to_rgb_string("rgb(68.2, 1.0, 84.4)") == "rgb(68, 1, 84)" + assert to_rgb_string("#123456") == "rgb(18, 52, 86)" + assert to_rgb_string("#12345680") == "rgba(18, 52, 86, 0.501961)" + assert to_rgb_string("red") == "rgb(255, 0, 0)" + + def test_to_rgb_string_rejects_invalid_colors(self): + """Unknown names, out-of-range components and non-strings raise a ValueError.""" + for color in ("notacolor", "rgb(256, 0, 0)", "rgba(0, 0, 0, 2)", 12): + with pytest.raises(ValueError, match="is not a valid color"): + to_rgb_string(color) + + def test_parse_rgb_ignores_opacity(self): + """parse_rgb returns the components of any supported color, without its opacity.""" + assert parse_rgb("rgba(244, 192, 0, 0.5)") == (244, 192, 0) + assert parse_rgb("#123456") == (18, 52, 86) + + def test_normalize_colors_named_continuous_scale(self): + """A scale name is sampled to as many colors as the palette's scale holds.""" + palette = select_palette(colors_loading(), "default") + normalized = normalize_colors({"confusion_matrix_colorscale": "viridis_r"}, palette) + colors = normalized["confusion_matrix_colorscale"] + assert len(colors) == len(palette["confusion_matrix_colorscale"]) + assert colors[0] == "rgb(253, 231, 37)" + assert colors[-1] == "rgb(68, 1, 84)" + + def test_normalize_colors_warns_on_non_diverging_contribution_scale(self): + """A sequential scale for signed contributions warns; a diverging one does not.""" + palette = select_palette(colors_loading(), "default") + with pytest.warns(UserWarning, match="'viridis' is not a diverging scale"): + normalize_colors({"contrib_colorscale": "viridis"}, palette) + with warnings.catch_warnings(): + warnings.simplefilter("error") + normalized = normalize_colors({"contrib_colorscale": "rdbu_r"}, palette) + assert len(normalized["contrib_colorscale"]) == len(palette["contrib_colorscale"]) + + def test_normalize_colors_named_qualitative_palette(self): + """A qualitative palette name is replaced by its colors, hex codes included.""" + palette = select_palette(colors_loading(), "default") + normalized = normalize_colors({"interaction_discrete": "plotly", "compare_plot": "Set2"}, palette) + assert normalized["interaction_discrete"][0] == "rgb(99, 110, 250)" + assert normalized["compare_plot"][0] == "rgb(102, 194, 165)" + + def test_normalize_colors_rejects_invalid_names(self): + """An unknown scale or palette name, or a color where a scale is expected, raises a ValueError.""" + palette = select_palette(colors_loading(), "default") + with pytest.raises(ValueError, match="'contrib_colorscale': 'red' is not a plotly color scale name"): + normalize_colors({"contrib_colorscale": "red"}, palette) + with pytest.raises(ValueError, match="'compare_plot': 'nope' is not a plotly qualitative palette name"): + normalize_colors({"compare_plot": "nope"}, palette) + + def test_normalize_colors_names_the_key_of_an_invalid_color(self): + """An invalid color nested in a list, a dict or a single value names its key.""" + palette = select_palette(colors_loading(), "default") + for overrides in ({"title_color": "nope"}, {"featureimp_bar": {"1": "nope"}}, {"compare_plot": ["nope"]}): + key = next(iter(overrides)) + with pytest.raises(ValueError, match=f"Invalid value for '{key}'"): + normalize_colors(overrides, palette) + with pytest.raises(ValueError, match="expected a color, a list or a dict of colors"): + normalize_colors({"title_color": 3}, palette) + + def test_normalize_colors_converts_nested_and_list_colors(self): + """Colors inside nested mappings and lists are converted too.""" + palette = select_palette(colors_loading(), "default") + normalized = normalize_colors({"featureimp_bar": {"1": "#000000"}, "compare_plot": ("red", "blue")}, palette) + assert normalized == {"featureimp_bar": {"1": "rgb(0, 0, 0)"}, "compare_plot": ["rgb(255, 0, 0)", "rgb(0, 0, 255)"]} + + def test_normalize_colors_warns_on_unknown_key(self): + """An unknown key warns with the closest valid key and is still converted.""" + palette = select_palette(colors_loading(), "default") + with pytest.warns(UserWarning, match="Unknown color key 'titel_color'.*Did you mean 'title_color'"): + normalized = normalize_colors({"titel_color": "red"}, palette) + assert normalized == {"titel_color": "rgb(255, 0, 0)"} + + def test_resolve_colors(self): + """resolve_colors returns the whole palette with the normalized overrides merged.""" + resolved = resolve_colors("blues", {"title_color": "#000000"}) + blues = select_palette(colors_loading(), "blues") + assert resolved["title_color"] == "rgb(0, 0, 0)" + assert resolved["webapp_title"] == blues["webapp_title"] + assert resolved.keys() == blues.keys() + + def test_resolve_nlp_theme_named_scale_and_hex(self): + """The NLP theme samples a scale name instead of splitting it, and converts hex colors.""" + theme = resolve_nlp_theme(colors_dict={"confusion_matrix_colorscale": "viridis", "nlp_xpl_positive": "#123456"}) + assert theme.confusion_scale[0] == "rgb(68, 1, 84)" + assert all(color.startswith("rgb(") for color in theme.confusion_scale) + assert theme.xpl_positive == "rgb(18, 52, 86)" From 2867ffa882b6882ea3197e7145723a74c7f082f6 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 13:54:13 +0100 Subject: [PATCH 05/13] fix(plots): accept any colour format in the NLP highlight plots --- shapash/plots/plot_backend_comparison.py | 10 +++++----- shapash/plots/plot_sentence_highlight.py | 15 ++++----------- shapash/webapp/nlp_app.py | 6 ++++-- .../plots/test_plot_backend_comparison.py | 6 ++++++ .../plots/test_plot_sentence_highlight.py | 13 +++++++++++++ 5 files changed, 32 insertions(+), 18 deletions(-) diff --git a/shapash/plots/plot_backend_comparison.py b/shapash/plots/plot_backend_comparison.py index 93167a72..3d3a5466 100644 --- a/shapash/plots/plot_backend_comparison.py +++ b/shapash/plots/plot_backend_comparison.py @@ -26,8 +26,8 @@ from dash import html from plotly import graph_objs as go -from shapash.plots.plot_sentence_highlight import _parse_rgb, _shap_style -from shapash.style.style_utils import DEFAULT_NLP_THEME +from shapash.plots.plot_sentence_highlight import _shap_style +from shapash.style.style_utils import DEFAULT_NLP_THEME, parse_rgb # Backend identity colors, assigned in this fixed order (never cycled) — the reference categorical # palette's first slots, validated for colour-vision-deficiency separation. Only the grouped bar @@ -52,7 +52,7 @@ def _check(tokens: Sequence[str], values_by_backend: Mapping[str, np.ndarray]) - def _opaque(color: str) -> str: - r, g, b = _parse_rgb(color) + r, g, b = parse_rgb(color) return f"rgb({r},{g},{b})" @@ -247,7 +247,7 @@ def plot_backend_highlight( subtitle : str, optional A line shown under the legend (e.g. agreement scores). color_positive, color_negative : str - ``rgb(...)``/``rgba(...)`` strings, as for + Colors, as for :func:`~shapash.plots.plot_sentence_highlight.plot_sentence_highlight`. Returns @@ -255,7 +255,7 @@ def plot_backend_highlight( html.Div """ values_by_backend = _check(tokens, values_by_backend) - pos_rgb, neg_rgb = _parse_rgb(color_positive), _parse_rgb(color_negative) + pos_rgb, neg_rgb = parse_rgb(color_positive), parse_rgb(color_negative) span_base = {"padding": "3px 5px", "borderRadius": "3px", "margin": "2px 1px", "display": "inline-block"} unattributed = {**span_base, "color": "#aaaaaa", "textDecoration": "line-through"} diff --git a/shapash/plots/plot_sentence_highlight.py b/shapash/plots/plot_sentence_highlight.py index 68d7724b..1e9ee902 100644 --- a/shapash/plots/plot_sentence_highlight.py +++ b/shapash/plots/plot_sentence_highlight.py @@ -13,18 +13,11 @@ import numpy as np from dash import html -from shapash.style.style_utils import DEFAULT_NLP_THEME +from shapash.style.style_utils import DEFAULT_NLP_THEME, parse_rgb _SPECIAL_RE = re.compile(r"^\[.*\]$|^##|^\s*$") -def _parse_rgb(color: str) -> tuple[int, int, int]: - """Parse a ``rgb(r, g, b)``/``rgba(r, g, b, a)`` string (the ``colors.json`` format) to ints.""" - nums = color.replace("rgba", "").replace("rgb", "").replace("(", "").replace(")", "").split(",") - r, g, b = (int(float(n)) for n in nums[:3]) - return r, g, b - - def _shap_style( val: float, max_abs: float, pos_rgb: tuple[int, int, int], neg_rgb: tuple[int, int, int] ) -> dict[str, str]: @@ -74,8 +67,8 @@ def plot_sentence_highlight( symmetry with the other plot functions. color_positive, color_negative : str Span background for a non-negative / negative contribution, interpolated from white by - magnitude. Must be a ``rgb(r, g, b)``/``rgba(r, g, b, a)`` string (the ``colors.json`` - format). Default to the ``"default"`` palette's ``nlp_xpl_positive``/``nlp_xpl_negative`` + magnitude. Any ``rgb(...)``/``rgba(...)`` string, hex code or color name; the + opacity is ignored. Default to the ``"default"`` palette's ``nlp_xpl_positive``/``nlp_xpl_negative`` — see :class:`~shapash.webapp.nlp_app.NlpWebApp`'s ``palette_name``/``colors_dict`` to theme every NLP chart at once instead of overriding this one call. @@ -92,7 +85,7 @@ def plot_sentence_highlight( if max_abs == 0: max_abs = 1.0 - pos_rgb, neg_rgb = _parse_rgb(color_positive), _parse_rgb(color_negative) + pos_rgb, neg_rgb = parse_rgb(color_positive), parse_rgb(color_negative) _span_base = { "padding": "3px 5px", diff --git a/shapash/webapp/nlp_app.py b/shapash/webapp/nlp_app.py index eb94dfe4..d7271cc7 100644 --- a/shapash/webapp/nlp_app.py +++ b/shapash/webapp/nlp_app.py @@ -175,8 +175,10 @@ class NlpWebApp: colors_dict : dict[str, str], optional Per-key overrides merged on top of *palette_name*, same shape and key names as ``colors.json`` and as ``SmartExplainer``'s own ``colors_dict`` (see - ``smart_explainer.py``'s ``define_style``). Only ``webapp_bkg`` (header band) and - ``webapp_title`` (accent color) are read today; other keys are accepted but unused. + ``smart_explainer.py``'s ``define_style``), validated the same way. The NLP webapp + reads ``webapp_bkg`` (header band), ``webapp_title`` (accent color), + ``nlp_xpl_positive``/``nlp_xpl_negative`` (signed contributions) and + ``confusion_matrix_colorscale`` (error analysis); other keys are accepted but unused. info : dict[str, str], optional Extra ``label -> value`` facts shown in the header's "ⓘ" popover, layered on top of what ``explanation`` already carries (``model_id``, ``architecture`` — each omitted when the diff --git a/tests/unit_tests/plots/test_plot_backend_comparison.py b/tests/unit_tests/plots/test_plot_backend_comparison.py index 165114bc..3354d118 100644 --- a/tests/unit_tests/plots/test_plot_backend_comparison.py +++ b/tests/unit_tests/plots/test_plot_backend_comparison.py @@ -31,6 +31,12 @@ def _texts(component) -> list[str]: class TestHeatmap: + def test_accepts_hex_colors(self): + fig = plot_backend_heatmap(TOKENS, VALUES, color_positive="#123456", color_negative="rgba(0, 0, 255, 0.5)") + scale = fig.data[0].colorscale + assert scale[0][1] == "rgb(0,0,255)" + assert scale[-1][1] == "rgb(18,52,86)" + def test_one_row_per_backend_one_column_per_token(self): fig = plot_backend_heatmap(TOKENS, VALUES) heat = fig.data[0] diff --git a/tests/unit_tests/plots/test_plot_sentence_highlight.py b/tests/unit_tests/plots/test_plot_sentence_highlight.py index eb7b980c..c8365cb9 100644 --- a/tests/unit_tests/plots/test_plot_sentence_highlight.py +++ b/tests/unit_tests/plots/test_plot_sentence_highlight.py @@ -23,6 +23,19 @@ def test_has_children(self): # legend + spans div + summary self.assertGreaterEqual(len(result.children), 3) + def test_accepts_hex_and_named_colors(self): + """Hex codes and color names are accepted; the strongest contribution takes the full color.""" + result = plot_sentence_highlight(self.tokens, self.values, color_positive="#123456", color_negative="blue") + + def backgrounds(component): + style = getattr(component, "style", None) or {} + children = getattr(component, "children", None) + children = children if isinstance(children, list) else [children] if children is not None else [] + own = [style["backgroundColor"]] if "backgroundColor" in style else [] + return own + [bg for child in children for bg in backgrounds(child)] + + self.assertIn("rgb(18,52,86)", backgrounds(result)) + def test_raises_on_2d_values(self): with self.assertRaises(ValueError): plot_sentence_highlight(self.tokens, np.zeros((5, 3))) From 3d517cf7535a2c9b531a3fefa3519e910a4cb55f Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 16:53:39 +0100 Subject: [PATCH 06/13] chore: correct statement about contribution signs --- shapash/style/style_utils.py | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/shapash/style/style_utils.py b/shapash/style/style_utils.py index a76f4e85..e841306a 100644 --- a/shapash/style/style_utils.py +++ b/shapash/style/style_utils.py @@ -120,7 +120,7 @@ def merge_palette(palette: dict[str, Any], overrides: dict[str, Any] | None) -> ) # Palette keys holding a list of distinct colors: they also accept a plotly qualitative palette name. DISCRETE_COLOR_KEYS = frozenset({"interaction_discrete", "compare_plot"}) -# Scales drawing signed values: a non-diverging scale hides the sign, so it draws a warning. +# Scales also drawing signed values (correlations): a non-diverging scale hides the sign, so it draws a warning. SIGNED_SCALE_KEYS = frozenset({"contrib_colorscale"}) _RGB_PATTERN = re.compile(r"^\s*rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)\s*$") @@ -209,8 +209,9 @@ def _sample_named_scale(key: str, name: str, n_colors: int) -> list[str]: raise ValueError(f"Invalid value for {key!r}: {name!r} is not a plotly color scale name.") from exc if key in SIGNED_SCALE_KEYS and name.lower().removesuffix("_r") not in _named_lists(plotly_colors.diverging): warnings.warn( - f"{name!r} is not a diverging scale: with it, {key!r} no longer shows whether a contribution " - "is positive or negative. A diverging scale such as 'RdBu' keeps the sign visible.", + f"{name!r} is not a diverging scale: the correlation plots, which also use {key!r}, will no " + "longer show whether a correlation is positive or negative. A diverging scale such as 'RdBu' " + "keeps the sign visible.", UserWarning, stacklevel=6, ) From c6f2ec30ee92789240c5b2d683f3f98d66ef538b Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 16:55:11 +0100 Subject: [PATCH 07/13] doc(tutorial): add supported options to colour notebook --- tutorial/common/tuto-common02-colors.ipynb | 76 ++++++++++++++++++++-- 1 file changed, 72 insertions(+), 4 deletions(-) diff --git a/tutorial/common/tuto-common02-colors.ipynb b/tutorial/common/tuto-common02-colors.ipynb index fe546d7a..a1a83f95 100644 --- a/tutorial/common/tuto-common02-colors.ipynb +++ b/tutorial/common/tuto-common02-colors.ipynb @@ -15,6 +15,7 @@ "- Use `palette_name` parameter\n", "- Use `colors_dict` parameter\n", "- Change the colors after compiling the explainer\n", + "- Use plotly color scales\n", "\n", "Data from Kaggle [House Prices](https://www.kaggle.com/c/house-prices-advanced-regression-techniques/data)" ] @@ -467,7 +468,7 @@ "source": [ "### Option 2: define your own colors with the `colors_dict` parameter\n", "\n", - "The colors you declare replace those of the palette.\n", + "The colors you declare replace those of the palette. Colors can be `rgb(...)` or `rgba(...)` strings, hex codes (`\"#1f77b4\"`) or color names (`\"red\"`).\n", "\n", "In the example below, we replace the colors used in the feature importance bar plot:" ] @@ -505,9 +506,8 @@ "outputs": [], "source": [ "# Now we replace these colors using the colors_dict parameter\n", - "# Only colors '1' and '2' change: we start from the current colors and update them\n", - "new_feature_imp_bar = xpl.colors_dict[\"featureimp_bar\"].copy()\n", - "new_feature_imp_bar.update({\"1\": \"rgba(100, 120, 150, 1)\", \"2\": \"rgba(120, 103, 50, 0.8)\"})\n", + "# Only colors '1' and '2' change: the other colors of featureimp_bar keep the palette's values\n", + "new_feature_imp_bar = {\"1\": \"rgba(100, 120, 150, 1)\", \"2\": \"rgba(120, 103, 50, 0.8)\"}\n", "\n", "xpl2 = SmartExplainer(\n", " model=regressor,\n", @@ -706,6 +706,74 @@ "source": [ "xpl3.plot.contribution_plot(\"1stFlrSF\")" ] + }, + { + "cell_type": "markdown", + "id": "6a242664", + "metadata": {}, + "source": [ + "### Option 4: use plotly color scales\n", + "\n", + "The continuous scales (`contrib_colorscale`, `confusion_matrix_colorscale`, `interaction_scale`, `feature_contributions_cumulative`) also accept a [plotly color scale name](https://plotly.com/python/builtin-colorscales/), and the lists of distinct colors (`interaction_discrete`, `compare_plot`) a [plotly qualitative palette name](https://plotly.com/python/discrete-color/). Add `_r` to a scale name to reverse it.\n", + "\n", + "`contrib_colorscale` colors the points by prediction in the contribution plots, and the correlations in the correlation plots. Keep a diverging scale such as `RdBu` for it: with a sequential scale such as `viridis`, the correlation plots no longer show the sign of a correlation, and Shapash warns about it.\n", + "\n", + "Calling `define_style` with `colors_dict` only keeps the `blues` palette and the feature importance colors set above:" + ] + }, + { + "cell_type": "code", + "execution_count": 27, + "id": "f0f52e8b", + "metadata": {}, + "outputs": [], + "source": [ + "xpl3.define_style(colors_dict={\"contrib_colorscale\": \"RdBu_r\"})" + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "id": "d66d9c02", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 28, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xpl3.plot.contribution_plot(\"1stFlrSF\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "a8daff83", + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "" + ] + }, + "execution_count": 29, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "xpl3.plot.features_importance()" + ] } ], "metadata": { From d66fa173132e3943e9d57f4fd5ae6c0140bf6710 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 17:39:19 +0100 Subject: [PATCH 08/13] fix(report): apply the explainer's style to distribution plots --- shapash/plots/plot_univariate.py | 85 ++++++++++++------- shapash/report/blocks.py | 23 +++-- tests/unit_tests/report/test_plots.py | 29 ++++++- .../report/test_report_generation.py | 15 ++++ 4 files changed, 114 insertions(+), 38 deletions(-) diff --git a/shapash/plots/plot_univariate.py b/shapash/plots/plot_univariate.py index 51076fe9..7b88de8e 100644 --- a/shapash/plots/plot_univariate.py +++ b/shapash/plots/plot_univariate.py @@ -12,14 +12,17 @@ from shapash.utils.utils import adjust_title_height, compute_digit_number -def _series_color(style_dict: dict[str, Any], key: Any, index: int) -> str: +def _series_color(style_dict: dict[str, Any], hue_colors: dict[Any, str] | None, key: Any, index: int) -> str: """ Color of one curve or bar group of a distribution plot. Parameters ---------- style_dict : dict[str, Any] - Resolved style, possibly extended with explicit colors keyed by level or column name. + Resolved style. Explicit colors keyed by level or column name are still read from it, + for callers passing them through ``colors_dict``. + hue_colors : dict[Any, str] or None + Explicit colors keyed by level of the hue column, or by column name when there is no hue. key : Any Level of the hue column, or the column name when there is no hue. index : int @@ -30,6 +33,8 @@ def _series_color(style_dict: dict[str, Any], key: Any, index: int) -> str: str The explicit color given for ``key``, else the palette's discrete colors in turn. """ + if hue_colors and key in hue_colors: + return hue_colors[key] color = style_dict.get(key) if isinstance(color, str): return color @@ -37,11 +42,34 @@ def _series_color(style_dict: dict[str, Any], key: Any, index: int) -> str: return discrete_colors[index % len(discrete_colors)] +def _distribution_style(colors_dict: dict[str, Any] | None, palette_name: str) -> dict[str, Any]: + """ + Style of a distribution plot: the palette's style, updated with ``colors_dict``. + + Parameters + ---------- + colors_dict : dict[str, Any] or None + Resolved style, or a partial one, such as explicit colors keyed by hue level. + palette_name : str + Palette completing ``colors_dict`` when it lacks a key the plot needs. + + Returns + ------- + dict[str, Any] + The style used by the plot. + """ + keys = ["dict_title", "dict_xaxis", "dict_yaxis", "interactions_discrete_colors"] + if colors_dict and all(key in colors_dict for key in keys): + return dict(colors_dict) + return define_style(get_palette(palette_name)) | (colors_dict or {}) + + def plot_distribution( df_all: pd.DataFrame, col: str, hue: str | None = None, colors_dict: dict[str, Any] | None = None, + hue_colors: dict[Any, str] | None = None, width: int = 700, height: int = 500, palette_name: str = "default", @@ -70,14 +98,17 @@ def plot_distribution( hue : Optional[str], optional The name of the column used to differentiate between groups (e.g., 'train' and 'test'). colors_dict : dict[str, Any] or None, optional - A dictionary specifying the colors to be used for each group. If not provided, - a default color palette will be used. + Resolved style of the plot, such as ``SmartExplainer.plot._style_dict``. Missing keys + are taken from ``palette_name``. + hue_colors : dict[Any, str] or None, optional + Color of each group, keyed by level of ``hue`` (or by ``col`` without hue). Groups + not listed take the palette's discrete colors in turn. width : int, optional, default=700 The width of the generated figure, in pixels. height : int, optional, default=500 The height of the generated figure, in pixels. palette_name : str, optional, default="default" - The name of the color palette to be used if `colors_dict` is not provided. + Palette used for the keys missing from `colors_dict`. nb_cat_max : int, optional, default=7 Maximum number of categories to display. Categories beyond this limit are grouped into a new 'Other' category (only for categorical features). @@ -113,6 +144,7 @@ def plot_distribution( col, hue=hue, colors_dict=colors_dict, + hue_colors=hue_colors, width=width, height=height, palette_name=palette_name, @@ -127,6 +159,7 @@ def plot_distribution( col, hue=hue, colors_dict=colors_dict, + hue_colors=hue_colors, width=width, height=height, palette_name=palette_name, @@ -145,6 +178,7 @@ def plot_continuous_distribution( col: str, hue: str | None = None, colors_dict: dict[str, Any] | None = None, + hue_colors: dict[Any, str] | None = None, width: int = 700, height: int = 500, palette_name: str = "default", @@ -164,13 +198,16 @@ def plot_continuous_distribution( hue : Optional[str] The column used to distinguish the values (e.g., 'train' and 'test'). colors_dict : dict[str, Any] or None - Dictionary of colors for hue levels. + Resolved style of the plot. Missing keys are taken from ``palette_name``. + hue_colors : dict[Any, str] or None + Color of each group, keyed by level of ``hue`` (or by ``col`` without hue). Groups + not listed take the palette's discrete colors in turn. width : int, optional, default=700 The width of the generated figure, in pixels. height : int, optional, default=500 The height of the generated figure, in pixels. palette_name : str, optional, default="default" - The name of the color palette to use if `colors_dict` is not provided. + Palette used for the keys missing from `colors_dict`. nb_hue_max : int, optional, default=7 Maximum number of hue categories to display. Categories beyond this limit are grouped into a new 'Other' category. @@ -185,14 +222,7 @@ def plot_continuous_distribution( Plotly figure object representing the KDE plot, or None when there are fewer than five data points and no hue is specified. """ - if colors_dict: - style_dict = {} - keys = ["dict_title", "dict_xaxis", "dict_yaxis", "interactions_discrete_colors"] - if any(key not in colors_dict for key in keys): - style_dict = define_style(get_palette(palette_name)) - style_dict.update(colors_dict) - else: - style_dict = define_style(get_palette(palette_name)) + style_dict = _distribution_style(colors_dict, palette_name) filtered_data = df_all.copy() if filtered_data[col].unique().shape[0] > 200: @@ -240,7 +270,7 @@ def plot_continuous_distribution( for x, y in zip(x_values, y_values, strict=False) ] - color = _series_color(style_dict, level, i) + color = _series_color(style_dict, hue_colors, level, i) fig.add_trace( go.Scatter( @@ -271,7 +301,7 @@ def plot_continuous_distribution( for x, y in zip(x_values, y_values, strict=False) ] - color = _series_color(style_dict, col, 0) + color = _series_color(style_dict, hue_colors, col, 0) fig.add_trace( go.Scatter( @@ -323,6 +353,7 @@ def plot_categorical_distribution( nb_cat_max: int = 7, nb_hue_max: int = 7, colors_dict: dict[str, Any] | None = None, + hue_colors: dict[Any, str] | None = None, width: int = 700, height: int = 500, palette_name: str = "default", @@ -350,13 +381,16 @@ def plot_categorical_distribution( Maximum number of hue categories to display. Categories beyond this limit are grouped into a new 'Other' category. colors_dict : dict[str, Any] or None - Dictionary of colors for categories. + Resolved style of the plot. Missing keys are taken from ``palette_name``. + hue_colors : dict[Any, str] or None + Color of each group, keyed by level of ``hue`` (or by ``col`` without hue). Groups + not listed take the palette's discrete colors in turn. width : int, optional, default=700 The width of the generated figure, in pixels. height : int, optional, default=500 The height of the generated figure, in pixels. palette_name : str, optional, default="default" - The name of the color palette to use if `colors_dict` is not provided. + Palette used for the keys missing from `colors_dict`. file_name : str or None, optional Path to save the plot as an HTML file. If None, the plot will not be saved, by default None. auto_open : bool, optional @@ -368,14 +402,7 @@ def plot_categorical_distribution( Plotly figure object representing the bar plot. """ df_all = df_all.copy() - if colors_dict: - style_dict = {} - keys = ["dict_title", "dict_xaxis", "dict_yaxis", "interactions_discrete_colors"] - if any(key not in colors_dict for key in keys): - style_dict = define_style(get_palette(palette_name)) - style_dict.update(colors_dict) - else: - style_dict = define_style(get_palette(palette_name)) + style_dict = _distribution_style(colors_dict, palette_name) if hue: unique_hues = df_all[hue].unique() @@ -413,7 +440,7 @@ def plot_categorical_distribution( if hue: for i, hue_val in enumerate(hue_order): subset = df_cat[df_cat[hue] == hue_val] - color = _series_color(style_dict, hue_val, i) + color = _series_color(style_dict, hue_colors, hue_val, i) customdata = subset.apply( lambda row, hue_val=hue_val: ( @@ -435,7 +462,7 @@ def plot_categorical_distribution( ) data.append(bar) else: - color = _series_color(style_dict, col, 0) + color = _series_color(style_dict, hue_colors, col, 0) customdata = df_cat.apply( lambda row: ( diff --git a/shapash/report/blocks.py b/shapash/report/blocks.py index e62bf431..27b92a52 100644 --- a/shapash/report/blocks.py +++ b/shapash/report/blocks.py @@ -35,7 +35,6 @@ "orange": {"bg": "#fff9e6", "border": "#f4c000", "title": "#cc8833", "text": "#444444"}, } -TARGET_DISTRIBUTION_COLORS = {"pred": "#2255aa", "true": "#f4c000"} BlockContent: TypeAlias = tuple[str, list[Any]] TargetValues: TypeAlias = np.ndarray[Any, Any] | list[Any] ReportBlockConfig: TypeAlias = dict[str, Any] @@ -533,7 +532,8 @@ def block_feature_distribution( df_all=df_train_test, col=feature, hue=dataset_split, - colors_dict=self._feature_distribution_colors(), + colors_dict=self._plot_style(), + hue_colors=self._dataset_colors(), width=width, height=height, ) @@ -886,7 +886,8 @@ def block_target_distribution( df_all=df_target, col=target_name, hue="_dataset", - colors_dict=TARGET_DISTRIBUTION_COLORS, + colors_dict=self._plot_style(), + hue_colors=self._dataset_colors(), width=width, height=height, ) @@ -975,7 +976,8 @@ def block_target_analysis( df_all=distribution_df, col=target_name, hue="data_train_test", - colors_dict=self._feature_distribution_colors(), + colors_dict=self._plot_style(), + hue_colors=self._dataset_colors(), width=width, height=height, ) @@ -1162,7 +1164,8 @@ def block_univariate_analysis( df_all=df, col=col, hue=col_splitter, - colors_dict=self._feature_distribution_colors(), + colors_dict=self._plot_style(), + hue_colors=self._dataset_colors(), ) if fig is not None: fig.update_layout( @@ -1272,6 +1275,10 @@ def _feature_label(self, feature: str) -> str: return feature return self.explainer.features_dict.get(feature, feature) - def _feature_distribution_colors(self) -> dict[str, Any]: - smart_explainer = self._require_smart_explainer("feature_distribution") - return smart_explainer.colors_dict["report_feature_distribution"] + def _plot_style(self) -> dict[str, Any]: + """Resolved plot style of the explainer, with its palette and custom colors.""" + return self._require_smart_explainer("distribution").plot._style_dict + + def _dataset_colors(self) -> dict[str, str]: + """Colors of the train, test, pred and true series in the distribution plots.""" + return self._plot_style()["report_feature_distribution"] diff --git a/tests/unit_tests/report/test_plots.py b/tests/unit_tests/report/test_plots.py index 06a61523..c2272de3 100644 --- a/tests/unit_tests/report/test_plots.py +++ b/tests/unit_tests/report/test_plots.py @@ -12,7 +12,7 @@ from plotly import graph_objects as go -from shapash.style.style_utils import colors_loading +from shapash.style.style_utils import colors_loading, define_style, get_palette class TestPlots(unittest.TestCase): @patch("shapash.plots.plot_univariate.plot_continuous_distribution") @@ -120,6 +120,33 @@ def test_plot_categorical_distribution_uses_palette_colors(self): assert [trace.marker.color for trace in fig.data] == discrete[:2] assert no_hue.data[0].marker.color == discrete[0] + def test_plot_distribution_hue_colors(self): + """hue_colors sets the color of each level, for continuous and categorical features alike.""" + hue_colors = {"train": "rgb(1, 2, 3)", "test": "rgb(4, 5, 6)"} + continuous = pd.DataFrame({"x": np.arange(40), "split": ["train", "test"] * 20}) + categorical = pd.DataFrame({"x": [0, 1] * 4, "split": ["train"] * 4 + ["test"] * 4}) + + fig_cont = plot_distribution(continuous, "x", hue="split", hue_colors=hue_colors) + fig_cat = plot_distribution(categorical, "x", hue="split", hue_colors=hue_colors) + + assert {trace.name: trace.line.color for trace in fig_cont.data} == hue_colors + assert {trace.name: trace.marker.color for trace in fig_cat.data} == hue_colors + + def test_plot_distribution_style_from_colors_dict(self): + """A full style passed as colors_dict sets the title, and hue_colors wins over a level color in it.""" + style = define_style(get_palette("blues")) + style["dict_title"]["font"]["color"] = "rgb(7, 8, 9)" + style["train"] = "rgb(0, 0, 0)" + df = pd.DataFrame({"x": np.arange(40), "split": ["train", "test"] * 20}) + + fig = plot_distribution(df, "x", hue="split", colors_dict=style, hue_colors={"train": "rgb(1, 2, 3)"}) + + assert fig.layout.title.font.color == "rgb(7, 8, 9)" + colors = {trace.name: trace.line.color for trace in fig.data} + assert colors["train"] == "rgb(1, 2, 3)" + assert colors["test"] in style["interactions_discrete_colors"] + assert "train" not in define_style(get_palette("blues")) + def test_plot_distribution_cycles_palette_colors(self): """More levels than discrete colors reuse the colors in turn.""" discrete = colors_loading()["default"]["interaction_discrete"] diff --git a/tests/unit_tests/report/test_report_generation.py b/tests/unit_tests/report/test_report_generation.py index 8331ebad..d616e216 100644 --- a/tests/unit_tests/report/test_report_generation.py +++ b/tests/unit_tests/report/test_report_generation.py @@ -668,6 +668,21 @@ def test_block_confusion_matrix_uses_explainer_style(self): assert mock_cm.call_args.kwargs["colors_dict"] is smart_explainer.plot._style_dict + def test_distribution_blocks_use_explainer_style_and_dataset_colors(self): + """Distribution plots get the plotter's style and the palette's colors for each dataset.""" + runtime = _build_runtime() + style_dict = runtime._require_smart_explainer("distribution").plot._style_dict + fake_fig = go.Figure(go.Scatter(x=[1], y=[1])) + + with patch("shapash.report.blocks.plot_distribution", return_value=fake_fig) as mock_dist: + runtime.block_feature_distribution(feature="age") + runtime.block_target_distribution() + + assert len(mock_dist.call_args_list) == 2 + for call in mock_dist.call_args_list: + assert call.kwargs["colors_dict"] is style_dict + assert call.kwargs["hue_colors"] is style_dict["report_feature_distribution"] + def test_smart_explainer_required(self): rbm = ReportBlockMixin() with pytest.raises(ValueError): From 7b2242d0050bcab5d34da5f1baf56471bb31e54a Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 17:40:07 +0100 Subject: [PATCH 09/13] fix(report): stop clipping distribution plot captions and legends --- shapash/report/blocks.py | 45 ++++++++++--------- .../report/test_report_generation.py | 14 +++++- 2 files changed, 38 insertions(+), 21 deletions(-) diff --git a/shapash/report/blocks.py b/shapash/report/blocks.py index 27b92a52..29893c3c 100644 --- a/shapash/report/blocks.py +++ b/shapash/report/blocks.py @@ -24,6 +24,8 @@ from shapash.utils.transform import apply_postprocessing, handle_categorical_missing, inverse_transform if TYPE_CHECKING: + from plotly import graph_objects as go + from shapash.explainer import SmartExplainer from shapash.explainer.explainer import Explainer logger = logging.getLogger(__name__) @@ -40,6 +42,27 @@ ReportBlockConfig: TypeAlias = dict[str, Any] +# Room below a distribution plot for its tick labels, axis title and the title shown as a caption. +CAPTION_MARGIN_BOTTOM = 130 +# Room above it for the legend title. +CAPTION_MARGIN_TOP = 40 + + +def _title_below(fig: go.Figure) -> None: + """Show the title of a distribution plot as a caption below it, without clipping it or the legend.""" + fig.update_layout( + title={ + **fig.layout.title.to_plotly_json(), + "x": 0.5, + "xanchor": "center", + "y": 0.0, + "yanchor": "bottom", + "pad": {"b": 15}, + }, + margin={**fig.layout.margin.to_plotly_json(), "t": CAPTION_MARGIN_TOP, "b": CAPTION_MARGIN_BOTTOM}, + ) + + def block(method: Callable[..., Any]) -> Callable[..., pn.Column]: """Wrap block output in a standard report section container. @@ -982,16 +1005,7 @@ def block_target_analysis( height=height, ) if fig is not None: - fig.update_layout( - title={ - **fig.layout.title.to_plotly_json(), - "x": 0.5, - "xanchor": "center", - "y": 0.0, - "yanchor": "bottom", - }, - margin={**fig.layout.margin.to_plotly_json(), "t": 10, "b": 100}, - ) + _title_below(fig) dtype_label = str(series_dtype(y_test_series)) content = [ @@ -1168,16 +1182,7 @@ def block_univariate_analysis( hue_colors=self._dataset_colors(), ) if fig is not None: - fig.update_layout( - title={ - **fig.layout.title.to_plotly_json(), - "x": 0.5, - "xanchor": "center", - "y": 0.0, - "yanchor": "bottom", - }, - margin={**fig.layout.margin.to_plotly_json(), "t": 10, "b": 100}, - ) + _title_below(fig) col_stats = stats_to_table( test_stats=test_stats[col], train_stats=train_stats[col] if train_stats is not None else None, diff --git a/tests/unit_tests/report/test_report_generation.py b/tests/unit_tests/report/test_report_generation.py index d616e216..8fcc8c79 100644 --- a/tests/unit_tests/report/test_report_generation.py +++ b/tests/unit_tests/report/test_report_generation.py @@ -10,7 +10,7 @@ from shapash.backend import BaseBackend from shapash.explainer import SmartExplainer -from shapash.report.blocks import ReportBlockMixin, block +from shapash.report.blocks import CAPTION_MARGIN_BOTTOM, CAPTION_MARGIN_TOP, ReportBlockMixin, _title_below, block from shapash.report.core import ( _apply_html_head_metadata, _inject_favicon_links, @@ -683,6 +683,18 @@ def test_distribution_blocks_use_explainer_style_and_dataset_colors(self): assert call.kwargs["colors_dict"] is style_dict assert call.kwargs["hue_colors"] is style_dict["report_feature_distribution"] + def test_title_below_keeps_title_and_legend_inside_the_figure(self): + """The caption title sits above the bottom edge, with room for the axis below and the legend above.""" + fig = go.Figure(go.Scatter(x=[1], y=[1])) + fig.update_layout(title={"text": "Distribution of age", "font": {"size": 24}}, margin={"l": 90, "t": 100, "b": 70}) + + _title_below(fig) + + assert fig.layout.title.text == "Distribution of age" + assert fig.layout.title.font.size == 24 + assert (fig.layout.title.y, fig.layout.title.yanchor, fig.layout.title.pad.b) == (0.0, "bottom", 15) + assert (fig.layout.margin.t, fig.layout.margin.b, fig.layout.margin.l) == (CAPTION_MARGIN_TOP, CAPTION_MARGIN_BOTTOM, 90) + def test_smart_explainer_required(self): rbm = ReportBlockMixin() with pytest.raises(ValueError): From 988f6ce9fd3ca2d3db3c1d85081392f7b853b311 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 17:41:36 +0100 Subject: [PATCH 10/13] feat(style): make clustering colours configurable --- shapash/plots/plot_evaluation_metrics.py | 12 +++--- shapash/style/colors.json | 12 ++++++ shapash/style/style_utils.py | 1 + .../plots/test_plot_evaluation_metrics.py | 38 +++++++++++++------ tests/unit_tests/style/test_style_utils.py | 6 +++ 5 files changed, 53 insertions(+), 16 deletions(-) diff --git a/shapash/plots/plot_evaluation_metrics.py b/shapash/plots/plot_evaluation_metrics.py index 93bf2e9d..d0f4e498 100644 --- a/shapash/plots/plot_evaluation_metrics.py +++ b/shapash/plots/plot_evaluation_metrics.py @@ -971,7 +971,8 @@ def plot_clustering_by_explainability( marker_size : int, optional, default=10 Size of the data point markers in the plot. style_dict : dict[str, Any] or None, optional, default=None - Custom styling options (e.g., fonts, layout settings). + Resolved style, such as ``SmartExplainer.plot._style_dict``. Its ``clustering`` entry + colors the selected cluster and the other ones. The default palette is used when None. opacity : float, optional, default=0.8 Opacity of the data point markers (between 0 and 1). width : int, optional, default=900 @@ -1007,6 +1008,7 @@ def plot_clustering_by_explainability( """ if style_dict is None: style_dict = define_style(get_palette("default")) + cluster_colors = style_dict["clustering"] dict_title = build_tsne_title(title, subtitle, addnote, style_dict=style_dict, height=height) @@ -1092,12 +1094,12 @@ def plot_clustering_by_explainability( # Couleurs dynamiques pour le hover c_n = c # curve number if c_n == active_cluster: - fill = "rgba(255,0,0,0.30)" - line_color = "rgba(200,0,0,1)" + fill = cluster_colors["active_fill"] + line_color = cluster_colors["active_line"] else: if show_points: - fill = "rgba(150,150,150,0.15)" - line_color = "rgba(200,200,200,0.8)" + fill = cluster_colors["inactive_fill"] + line_color = cluster_colors["inactive_line"] else: fill = value_to_rgba(float(cluster_color[c]), colorscale, float(cmin), float(cmax), alpha=0.99) line_color = value_to_rgba( diff --git a/shapash/style/colors.json b/shapash/style/colors.json index cfb4e230..6407ead1 100644 --- a/shapash/style/colors.json +++ b/shapash/style/colors.json @@ -1,6 +1,12 @@ { "blues": { "axis_color": "rgb(50, 50, 50)", + "clustering": { + "active_fill": "rgba(255, 0, 0, 0.3)", + "active_line": "rgba(200, 0, 0, 1)", + "inactive_fill": "rgba(150, 150, 150, 0.15)", + "inactive_line": "rgba(200, 200, 200, 0.8)" + }, "compacity_bar": { "0": "rgba(230, 111, 0, 0.9)", "1": "rgba(0, 154, 203, 0.9)" @@ -121,6 +127,12 @@ }, "default": { "axis_color": "rgb(50, 50, 50)", + "clustering": { + "active_fill": "rgba(255, 0, 0, 0.3)", + "active_line": "rgba(200, 0, 0, 1)", + "inactive_fill": "rgba(150, 150, 150, 0.15)", + "inactive_line": "rgba(200, 200, 200, 0.8)" + }, "compacity_bar": { "0": "rgba(117, 152, 189, 0.9)", "1": "rgba(255, 166, 17, 0.9)" diff --git a/shapash/style/style_utils.py b/shapash/style/style_utils.py index e841306a..f6884b3b 100644 --- a/shapash/style/style_utils.py +++ b/shapash/style/style_utils.py @@ -411,6 +411,7 @@ def define_style(palette: dict[str, Any]) -> dict[str, Any]: style_dict["webapp_button"] = convert_string_to_int_keys(palette["webapp_button"]) style_dict["webapp_bkg"] = palette["webapp_bkg"] style_dict["webapp_title"] = palette["webapp_title"] + style_dict["clustering"] = palette["clustering"] return style_dict diff --git a/tests/unit_tests/plots/test_plot_evaluation_metrics.py b/tests/unit_tests/plots/test_plot_evaluation_metrics.py index 67deaa8c..b9d37333 100644 --- a/tests/unit_tests/plots/test_plot_evaluation_metrics.py +++ b/tests/unit_tests/plots/test_plot_evaluation_metrics.py @@ -1,17 +1,13 @@ import numpy as np import pandas as pd +import pytest from shapely.geometry import Polygon import shapash.plots.plot_evaluation_metrics as evaluation_metrics -from shapash.style.style_utils import define_style, get_palette +from shapash.style.style_utils import define_style, get_palette, resolve_colors -def test_plot_clustering_by_explainability_draws_clusters_when_enabled(monkeypatch): - projections = np.array([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]]) - polygon = Polygon([(0, 0), (1, 0), (1, 1), (0, 1)]) - values_to_project = pd.DataFrame(index=range(len(projections))) - color_value = [pd.DataFrame({"color": [0.0, 0.25, 0.75, 1.0]})] - +def _patch_cluster_geometry(monkeypatch, polygon): monkeypatch.setattr(evaluation_metrics, "move_points_towards_centroid", lambda points, *_args, **_kwargs: points) monkeypatch.setattr(evaluation_metrics, "compute_concave_hull", lambda *_args, **_kwargs: polygon) monkeypatch.setattr(evaluation_metrics, "smooth_polygon_contour", lambda shape: shape) @@ -22,23 +18,43 @@ def test_plot_clustering_by_explainability_draws_clusters_when_enabled(monkeypat ) monkeypatch.setattr(evaluation_metrics, "scale_points_within_cluster", lambda points, *_args: points) - fig = evaluation_metrics.plot_clustering_by_explainability( - values_to_project=values_to_project, + +def _plot_one_cluster(monkeypatch, style_dict, active_cluster=None): + projections = np.array([[0.0, 0.0], [1.0, 0.0], [1.0, 1.0], [0.0, 1.0]]) + _patch_cluster_geometry(monkeypatch, Polygon([(0, 0), (1, 0), (1, 1), (0, 1)])) + return evaluation_metrics.plot_clustering_by_explainability( + values_to_project=pd.DataFrame(index=range(len(projections))), hv_text={"clusters": ["cluster detail"], "points": [["point"] * len(projections)]}, - color_value=color_value, + color_value=[pd.DataFrame({"color": [0.0, 0.25, 0.75, 1.0]})], projections=projections, labels=np.zeros(len(projections), dtype=int), centers=np.array([[0.5, 0.5]]), - style_dict=define_style(get_palette("default")), + style_dict=style_dict, show_clusters=True, + active_cluster=active_cluster, ) + +def test_plot_clustering_by_explainability_draws_clusters_when_enabled(monkeypatch): + fig = _plot_one_cluster(monkeypatch, define_style(get_palette("default"))) + assert len(fig.data) == 2 assert fig.data[0].fill == "toself" assert fig.data[0].name == "Cluster 0" assert fig.data[1].mode == "markers" +@pytest.mark.parametrize(("active_cluster", "state"), [(0, "active"), (None, "inactive")]) +def test_plot_clustering_by_explainability_uses_palette_cluster_colors(monkeypatch, active_cluster, state): + """The selected cluster and the other ones take the palette's clustering colors, overrides included.""" + style_dict = define_style(resolve_colors("default", {"clustering": {f"{state}_fill": "#00ff00"}})) + + fig = _plot_one_cluster(monkeypatch, style_dict, active_cluster=active_cluster) + + assert fig.data[0].fillcolor == "rgb(0, 255, 0)" + assert fig.data[0].line.color == get_palette("default")["clustering"][f"{state}_line"] + + def test_prediction_regression_plot_trims_outliers_above_500_rows(): rng = np.random.default_rng(0) index = pd.RangeIndex(501) diff --git a/tests/unit_tests/style/test_style_utils.py b/tests/unit_tests/style/test_style_utils.py index c5c6be12..5382cbc9 100644 --- a/tests/unit_tests/style/test_style_utils.py +++ b/tests/unit_tests/style/test_style_utils.py @@ -231,6 +231,12 @@ def test_normalize_colors_warns_on_unknown_key(self): normalized = normalize_colors({"titel_color": "red"}, palette) assert normalized == {"titel_color": "rgb(255, 0, 0)"} + def test_every_palette_has_clustering_colors(self): + """Each palette gives the clustering plot its four colors, kept by define_style.""" + for name, palette in colors_loading().items(): + assert set(palette["clustering"]) == {"active_fill", "active_line", "inactive_fill", "inactive_line"}, name + assert define_style(palette)["clustering"] == palette["clustering"] + def test_resolve_colors(self): """resolve_colors returns the whole palette with the normalized overrides merged.""" resolved = resolve_colors("blues", {"title_color": "#000000"}) From c54668742c4d96f03c42af2d10ca2bd0fb373992 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 17:42:13 +0100 Subject: [PATCH 11/13] feat(explainer): add colors_dict to Consistency --- shapash/explainer/consistency.py | 19 ++++++++++++++----- .../unit_tests/explainer/test_consistency.py | 9 +++++++++ 2 files changed, 23 insertions(+), 5 deletions(-) diff --git a/shapash/explainer/consistency.py b/shapash/explainer/consistency.py index dac6870e..aa2e1dda 100644 --- a/shapash/explainer/consistency.py +++ b/shapash/explainer/consistency.py @@ -12,17 +12,26 @@ from plotly.subplots import make_subplots from sklearn.manifold import MDS -from shapash.style.style_utils import colors_loading, define_style, select_palette +from shapash.style.style_utils import define_style, resolve_colors from shapash.utils.dtypes import text_like_columns from shapash.utils.utils import adjust_title_height class Consistency: - """Consistency class.""" - - def __init__(self, palette_name: str = "default") -> None: + """ + Compare the contributions computed by several explainability methods. + + Parameters + ---------- + palette_name : str, default="default" + Name of the color palette, as for ``SmartExplainer``. + colors_dict : dict[str, Any] or None, default=None + Colors overriding the palette's, in the formats ``SmartExplainer`` accepts. + """ + + def __init__(self, palette_name: str = "default", colors_dict: dict[str, Any] | None = None) -> None: self._palette_name = palette_name - self._style_dict = define_style(select_palette(colors_loading(), self._palette_name)) + self._style_dict = define_style(resolve_colors(palette_name, colors_dict)) def tuning_colorscale(self, values: pd.Series | pd.DataFrame) -> list[list[Any]]: """Adapts the color scale to the distribution of points. diff --git a/tests/unit_tests/explainer/test_consistency.py b/tests/unit_tests/explainer/test_consistency.py index 5fa962a7..14e986eb 100644 --- a/tests/unit_tests/explainer/test_consistency.py +++ b/tests/unit_tests/explainer/test_consistency.py @@ -40,6 +40,15 @@ def setUp(self): self.cns = Consistency() self.cns.compile(contributions=self.contributions, x=self.X) + def test_colors_dict(self): + """colors_dict overrides the palette's colors, in the formats SmartExplainer accepts.""" + cns = Consistency(palette_name="blues", colors_dict={"title_color": "#000000", "contrib_colorscale": "RdBu"}) + default = Consistency(palette_name="blues") + + assert cns._style_dict["dict_title_stability"]["font"]["color"] == "rgb(0, 0, 0)" + assert cns._style_dict["init_contrib_colorscale"][0] == "rgb(103, 0, 31)" + assert cns._style_dict["dict_xaxis"] == default._style_dict["dict_xaxis"] + def test_compile(self): assert isinstance(self.cns.methods, list) assert len(self.cns.methods) == len(self.contributions) From add9b8c4baac8b41a8397664341d92c259eb5ad2 Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Fri, 6 Nov 2026 17:42:45 +0100 Subject: [PATCH 12/13] chore(style): warn when setting the unused report_confusion_matrix key --- shapash/style/style_utils.py | 13 +++++++++++-- tests/unit_tests/style/test_style_utils.py | 6 ++++++ 2 files changed, 17 insertions(+), 2 deletions(-) diff --git a/shapash/style/style_utils.py b/shapash/style/style_utils.py index f6884b3b..821f7f18 100644 --- a/shapash/style/style_utils.py +++ b/shapash/style/style_utils.py @@ -123,6 +123,9 @@ def merge_palette(palette: dict[str, Any], overrides: dict[str, Any] | None) -> # Scales also drawing signed values (correlations): a non-diverging scale hides the sign, so it draws a warning. SIGNED_SCALE_KEYS = frozenset({"contrib_colorscale"}) +# Palette keys no plot reads, with the key to set instead. +UNUSED_COLOR_KEYS = {"report_confusion_matrix": "confusion_matrix_colorscale"} + _RGB_PATTERN = re.compile(r"^\s*rgba?\(\s*([\d.]+)\s*,\s*([\d.]+)\s*,\s*([\d.]+)\s*(?:,\s*([\d.]+)\s*)?\)\s*$") @@ -275,8 +278,8 @@ def normalize_colors(colors_dict: dict[str, Any] | None, palette: dict[str, Any] Warns ----- UserWarning - For a key the palette does not have, and for a non-diverging scale name given for - ``contrib_colorscale``. + For a key the palette does not have or no plot reads, and for a non-diverging scale + name given for ``contrib_colorscale``. """ normalized = {} for key, value in (colors_dict or {}).items(): @@ -284,6 +287,12 @@ def normalize_colors(colors_dict: dict[str, Any] | None, palette: dict[str, Any] close = difflib.get_close_matches(key, palette, n=1) hint = f" Did you mean {close[0]!r}?" if close else "" warnings.warn(f"Unknown color key {key!r}: no plot uses it.{hint}", UserWarning, stacklevel=4) + elif key in UNUSED_COLOR_KEYS: + warnings.warn( + f"Color key {key!r} has no effect: set {UNUSED_COLOR_KEYS[key]!r} instead.", + UserWarning, + stacklevel=4, + ) normalized[key] = _normalize_entry(key, value, palette.get(key)) return normalized diff --git a/tests/unit_tests/style/test_style_utils.py b/tests/unit_tests/style/test_style_utils.py index 5382cbc9..cca17fbc 100644 --- a/tests/unit_tests/style/test_style_utils.py +++ b/tests/unit_tests/style/test_style_utils.py @@ -231,6 +231,12 @@ def test_normalize_colors_warns_on_unknown_key(self): normalized = normalize_colors({"titel_color": "red"}, palette) assert normalized == {"titel_color": "rgb(255, 0, 0)"} + def test_normalize_colors_warns_on_unused_key(self): + """Setting a key no plot reads warns with the key to set instead.""" + palette = select_palette(colors_loading(), "default") + with pytest.warns(UserWarning, match="'report_confusion_matrix' has no effect: set 'confusion_matrix_colorscale'"): + normalize_colors({"report_confusion_matrix": ["red", "blue"]}, palette) + def test_every_palette_has_clustering_colors(self): """Each palette gives the clustering plot its four colors, kept by define_style.""" for name, palette in colors_loading().items(): From 350eda2fffb01b4a6c1b069e41b77795e96b3a5f Mon Sep 17 00:00:00 2001 From: Milton Minervino Date: Mon, 16 Nov 2026 10:42:03 +0100 Subject: [PATCH 13/13] docs(style): list the available palettes and colors.json keys in docstrings --- shapash/explainer/smart_explainer.py | 15 ++++++++++----- shapash/webapp/nlp_app.py | 5 +++-- 2 files changed, 13 insertions(+), 7 deletions(-) diff --git a/shapash/explainer/smart_explainer.py b/shapash/explainer/smart_explainer.py index 67800aae..48e19341 100644 --- a/shapash/explainer/smart_explainer.py +++ b/shapash/explainer/smart_explainer.py @@ -115,10 +115,13 @@ class SmartExplainer: title_story : str, optional Custom title used in visualizations and reports. Default is empty. palette_name : str, optional - Name of the color palette used for visualizations (see the `style` folder for options). + Name of the color palette used for visualizations: ``"default"`` or ``"blues"``, the + palettes defined in ``shapash/style/colors.json``. Defaults to ``"default"``. colors_dict : dict, optional - Colors overriding those of ``palette_name``, with the same keys as the palette. - A nested mapping such as ``featureimp_bar`` can be given partially. Colors can be + Colors overriding those of ``palette_name``, with the same keys as the palette (the + keys of the chosen palette in ``shapash/style/colors.json``, e.g. ``title_color``, + ``featureimp_bar``, ``contrib_colorscale``, ``webapp_bkg``). A nested mapping such as + ``featureimp_bar`` can be given partially. Colors can be ``rgb(...)``/``rgba(...)`` strings, hex codes or color names. A continuous scale (``contrib_colorscale``, ``confusion_matrix_colorscale``, ``interaction_scale``, ``feature_contributions_cumulative``) also accepts a plotly scale name such as @@ -334,11 +337,13 @@ def define_style(self, palette_name: str | None = None, colors_dict: dict[str, A Parameters ---------- palette_name : str, optional - Name of the palette to switch to. Switching palette discards the colors + Name of the palette to switch to: ``"default"`` or ``"blues"`` (see + ``shapash/style/colors.json``). Switching palette discards the colors overridden earlier, in the constructor or in a previous call. colors_dict : dict[str, Any], optional Colors to override, merged on top of the palette and of the overrides already - in place. Accepts the same values as the constructor's ``colors_dict``. + in place. Keys are those of ``shapash/style/colors.json``; accepts the same + values as the constructor's ``colors_dict``. Raises ------ diff --git a/shapash/webapp/nlp_app.py b/shapash/webapp/nlp_app.py index d7271cc7..33accfb3 100644 --- a/shapash/webapp/nlp_app.py +++ b/shapash/webapp/nlp_app.py @@ -168,8 +168,9 @@ class NlpWebApp: both become ``"/shapash-nlp-explainer/"`` — since that is the only spelling Dash accepts and a prefix copied from an nginx ``location`` easily arrives without one. palette_name : str, optional - Name of a palette in ``shapash/style/colors.json`` (the same file the tabular - ``SmartExplainer`` webapp draws its theme from — see ``smart_app.py``). Selects the + Name of a palette in ``shapash/style/colors.json`` (``"default"`` or ``"blues"``; the + same file the tabular ``SmartExplainer`` webapp draws its theme from — see + ``smart_app.py``). Selects the header's band color (``webapp_bkg``) and accent color (``webapp_title``). Defaults to ``"default"``, the same palette ``SmartExplainer`` falls back to. colors_dict : dict[str, str], optional