feat: Add categorical_agg operation for linked selections with categorical Bars (#6804)

Co-authored-by: Simon Høxbro Hansen <hoxbro@protonmail.com>
Co-authored-by: Philipp Rudiger <prudiger@anaconda.com>

Author: 3 people

examples/user_guide/Linked_Brushing.ipynb

@@ -12,7 +12,7 @@
     "import holoviews as hv\n",
     "from holoviews import opts\n",
     "from holoviews.operation import gridmatrix\n",
-    "from holoviews.operation.element import histogram\n",
+    "from holoviews.operation.element import categorical_agg, histogram\n",
     "from holoviews.selection import link_selections\n",
     "from holoviews.util.transform import dim\n",
     "\n",
@@ -475,6 +475,74 @@
     "mpg_ls.unlink(w_accel_scatter)"
    ]
   },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Categorical Dimensions with `categorical_agg`\n",
+    "\n",
+    "The `histogram` operation only works with numeric dimensions. For categorical \n",
+    "dimensions, use the built-in `categorical_agg` operation, which aggregates \n",
+    "a categorical dimension into a `Bars` element while preserving data lineage \n",
+    "for `link_selections`.\n"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "#### Why `categorical_agg` works with `link_selections`\n",
+    "\n",
+    "`categorical_agg` is an `Operation` subclass, so it remembers its source \n",
+    "element. When a selection is made, `link_selections` traces back through the \n",
+    "operation to the source (e.g. `Points`), applies the filter there, then \n",
+    "re-runs `categorical_agg` on the filtered subset — re-aggregating correctly.\n",
+    "\n",
+    "Pre-aggregated `hv.Bars(df.groupby(...))` does **not** work because it has \n",
+    "no source reference.\n"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": null,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "hv.extension('bokeh')\n",
+    "\n",
+    "rng = np.random.default_rng(42)\n",
+    "df = pd.DataFrame({\n",
+    "    'x': rng.normal(0, 1, 200),\n",
+    "    'y': rng.normal(0, 1, 200),\n",
+    "    'category': rng.choice(['A', 'B', 'C', 'D'], 200),\n",
+    "})\n",
+    "\n",
+    "ls = hv.link_selections.instance()\n",
+    "points = hv.Points(df, kdims=['x', 'y'], vdims=['category'])\n",
+    "\n",
+    "bars_count = categorical_agg(points, dimension='category')\n",
+    "bars_mean  = categorical_agg(points, dimension='category', value_dimension='y', function=np.mean)\n",
+    "hist_x     = histogram(points, dimension='x', num_bins=20)\n",
+    "\n",
+    "ls(points) + ls(bars_count) + ls(bars_mean) + ls(hist_x)"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Supported aggregation functions\n",
+    "\n",
+    "| Call | Result |\n",
+    "|------|--------|\n",
+    "| `categorical_agg(points, dimension='cat')` | Count per category |\n",
+    "| `categorical_agg(points, dimension='cat', value_dimension='y', function=np.sum)` | Sum of `y` per category |\n",
+    "| `categorical_agg(points, dimension='cat', value_dimension='y', function=np.mean)` | Mean of `y` |\n",
+    "| `categorical_agg(points, dimension='cat', value_dimension='y', function=np.std)` | Std deviation |\n",
+    "\n",
+    "You can also click individual bars to cross-filter (tap-to-select).\n"
+   ]
+  },
   {
    "cell_type": "markdown",
    "metadata": {},
@@ -558,8 +626,8 @@
     "\n",
     "<tr><td class=\"sG\">Area</td><td          class=\"sY\">Yes</td><td class=\"sY\">Yes</td><td class=\"sY\">Yes</td>\n",
     "    <td class=\"sN\">No </td></tr>\n",
-    "<tr><td class=\"sG\">Bars</td><td          class=\"sN\">No </td><td class=\"sN\">No </td><td class=\"sN\">No </td>\n",
-    "    <td class=\"sN\">No </td><td>Complicated to support stacked and multi-level bars</td></tr>\n",
+    "<tr><td class=\"sG\">Bars</td><td          class=\"sN\">Yes </td><td class=\"sN\">Yes </td><td class=\"sN\">No </td>\n",
+    "    <td class=\"sN\">No </td><td>Use categorical_agg with link_selections for tap-to-select on categorical bars</td></tr>\n",
     "<tr><td class=\"sG\">Bivariate</td><td     class=\"sY\">Yes</td><td class=\"sY\">Yes</td><td class=\"sY\">Yes</td>\n",
     "    <td class=\"sY\">Yes </td></tr>\n",
     "<tr><td class=\"sG\">BoxWhisker</td><td    class=\"sY\">Yes</td><td class=\"sY\">Yes</td><td class=\"sY\">Yes</td>\n",

holoviews/element/chart.py

@@ -10,7 +10,7 @@
     Rectangles,
     VectorField,
 )
-from .selection import Selection1DExpr
+from .selection import Selection1DExpr, SelectionBarsExpr
 
 
 class Chart(Dataset, Element2D):
@@ -188,7 +188,7 @@ class Spread(ErrorBars):
     group = param.String(default="Spread", constant=True)
 
 
-class Bars(Selection1DExpr, Chart):
+class Bars(SelectionBarsExpr, Chart):
     """Bars is a Chart element representing categorical observations
     using the height of rectangular bars. The key dimensions represent
     the categorical groupings of the data, but may also be used to

holoviews/element/selection.py

@@ -569,3 +569,32 @@ def _merge_regions(region1, region2, operation):
             new = len(contiguous)
             data = contiguous
         return NdOverlay([(i, region1.last.clone(l, u)) for i, (l, u) in enumerate(data)])
+
+
+class SelectionBarsExpr(Selection1DExpr):
+    """Mixin class for Bars adding tap/click-to-select on top of box-select.
+
+    Translates Selection1D tap events (integer row indices) into an
+    isin expression over the bar's key dimension for link_selections.
+    """
+
+    _selection_streams = (SelectionXY, Selection1D)
+
+    _selection_uses_selection1d_without_index_cols = True
+
+    def _get_selection_expr_for_stream_value(self, **kwargs):
+        index = kwargs.get("index")
+        index_cols = kwargs.get("index_cols")
+
+        if "index" in kwargs and index_cols is None:
+            if not index:
+                return None, None, None
+            kdim = self.kdims[0]
+            cat_vals = self.dimension_values(kdim, expanded=False)
+            clicked = [cat_vals[i] for i in index if 0 <= i < len(cat_vals)]
+            if clicked:
+                expr = dim(kdim).isin(list(util.unique_iterator(clicked)))
+                return expr, None, None
+            return None, None, None
+
+        return super()._get_selection_expr_for_stream_value(**kwargs)

holoviews/operation/element.py

@@ -44,7 +44,7 @@
     label_sanitizer,
 )
 from ..core.util.dependencies import _no_import_version, cp
-from ..element.chart import Histogram, Scatter
+from ..element.chart import Bars, Histogram, Scatter
 from ..element.path import Contours, Dendrogram, Polygons
 from ..element.raster import RGB, HeatMap, Image
 from ..element.util import categorical_aggregate2d  # noqa: F401
@@ -1101,6 +1101,69 @@ def _process(self, element, key=None, groupby=False):
         return Histogram((edges, hist), kdims=[dim], label=element.label, **params)
 
 
+class categorical_agg(Operation):
+    """Aggregates a categorical dimension of an element into a Bars element.
+
+    Because it is an Operation subclass it preserves data lineage,
+    allowing link_selections to cross-filter through the aggregation.
+    """
+
+    dimension = param.String(
+        default=None,
+        allow_None=True,
+        doc="Categorical dimension to group by.",
+    )
+
+    value_dimension = param.String(
+        default=None,
+        allow_None=True,
+        doc="Numeric dimension to aggregate. If None, counts rows per category.",
+    )
+
+    function = param.Callable(
+        default=np.size,
+        doc="Aggregation function applied to value_dimension values.",
+    )
+
+    label = param.String(
+        default=None,
+        allow_None=True,
+        doc="Label for the value axis. Auto-generated from function name if None.",
+    )
+
+    def _process(self, element, key=None):
+        if self.p.dimension is None:
+            raise ValueError("The dimension parameter is required for categorical_agg.")
+
+        cat_dim = element.get_dimension(self.p.dimension)
+        if cat_dim is None:
+            raise ValueError(f"Dimension '{self.p.dimension}' not found on the input element.")
+
+        cat_vals = element.dimension_values(self.p.dimension, expanded=True)
+        unique_cats = np.unique(cat_vals)
+
+        if self.p.value_dimension is None:
+            _, counts = np.unique(cat_vals, return_counts=True)
+            agg_label = self.p.label or "Count"
+            data = list(zip(unique_cats, counts, strict=True))
+        else:
+            val_dim = element.get_dimension(self.p.value_dimension)
+            if val_dim is None:
+                raise ValueError(
+                    f"Value dimension '{self.p.value_dimension}' not found on the input element."
+                )
+            num_vals = element.dimension_values(self.p.value_dimension, expanded=True)
+            results = []
+            for cat in unique_cats:
+                mask = cat_vals == cat
+                results.append(self.p.function(num_vals[mask]))
+            func_name = getattr(self.p.function, "__name__", "agg")
+            agg_label = self.p.label or f"{func_name}({self.p.value_dimension})"
+            data = list(zip(unique_cats, results, strict=True))
+
+        return Bars(data, kdims=[self.p.dimension], vdims=[agg_label])
+
+
 class decimate(Operation):
     """Decimates any column based Element to a specified number of random
     rows if the current element defined by the x_range and y_range

holoviews/plotting/bokeh/chart.py

@@ -1017,6 +1017,11 @@ class BarPlot(BarsMixin, ColorbarPlot, LegendPlot):
 
     selection_display = BokehOverlaySelectionDisplay()
 
+    default_tools = param.List(
+        default=["save", "pan", "wheel_zoom", "box_zoom", "reset", "tap"],
+        doc="Default tools for BarPlot. Includes tap for click-to-select with link_selections.",
+    )
+
     style_opts = base_properties + fill_properties + line_properties + ["bar_width", "cmap"]
 
     _nonvectorized_styles = [*base_properties, "bar_width", "cmap"]

holoviews/plotting/bokeh/element.py

@@ -3259,7 +3259,11 @@ def _get_colormapper(
 
         cmapper = self.handles.get(name)
         if cmapper is not None:
-            if cmapper.palette != palette:
+            try:
+                palette_changed = bool(cmapper.palette != palette)
+            except Exception:
+                palette_changed = True
+            if palette_changed:
                 cmapper.palette = palette
             opts = {k: opt for k, opt in opts.items() if getattr(cmapper, k) != opt}
             if opts:

holoviews/streams.py

@@ -1173,9 +1173,26 @@ def constants(self):
         }
 
     def transform(self):
-        # Skip index streams if no index_cols are provided
+        # Skip Selection1D when no index_cols, unless element opts in.
+        from .core.spaces import DynamicMap
+
+        source = self.source
+        if isinstance(source, DynamicMap):
+            element_type = source.type
+        else:
+            element_type = type(source)
+
+        uses_selection1d_standalone = getattr(
+            element_type, "_selection_uses_selection1d_without_index_cols", False
+        )
+
         for stream in self.input_streams:
-            if isinstance(stream, Selection1D) and stream._triggering and not self._index_cols:
+            if (
+                isinstance(stream, Selection1D)
+                and stream._triggering
+                and not self._index_cols
+                and not uses_selection1d_standalone
+            ):
                 return
         return super().transform()
 

holoviews/tests/element/test_selection.py

@@ -10,6 +10,7 @@
 
 import holoviews as hv
 from holoviews.element.selection import spatial_select_columnar
+from holoviews.streams import Selection1D, SelectionXY
 from holoviews.testing import assert_data_equal, assert_dict_equal, assert_element_equal
 
 from .._deps import dd, dd_skip, ds_skip, shapely_skip, spd_skip
@@ -221,6 +222,71 @@ def test_distribution_single_inverted(self):
         assert_element_equal(region, hv.NdOverlay({0: hv.HSpan(3, 7)}))
 
 
+class TestSelectionBarsExpr:
+    def setup_method(self):
+        import holoviews.plotting.bokeh  # noqa: F401
+
+        self._backend = hv.Store.current_backend
+        hv.Store.set_current_backend("bokeh")
+
+    def teardown_method(self):
+        hv.Store.current_backend = self._backend
+
+    def _make_bars(self):
+        return hv.Bars(
+            (["A", "B", "C", "D"], [10, 20, 5, 15]), kdims=["category"], vdims=["count"]
+        )
+
+    def test_bars_tap_single_category(self):
+        bars = self._make_bars()
+        expr, bbox, region = bars._get_selection_expr_for_stream_value(index=[1])
+        assert bbox is None
+        assert region is None
+        assert expr == hv.dim("category").isin(["B"])
+        assert_data_equal(
+            expr.apply(bars),
+            np.array([False, True, False, False]),
+        )
+
+    def test_bars_tap_multiple_categories(self):
+        bars = self._make_bars()
+        expr, bbox, region = bars._get_selection_expr_for_stream_value(index=[0, 2])
+        assert bbox is None
+        assert region is None
+        assert expr == hv.dim("category").isin(["A", "C"])
+        assert_data_equal(
+            expr.apply(bars),
+            np.array([True, False, True, False]),
+        )
+
+    def test_bars_tap_empty_index(self):
+        bars = self._make_bars()
+        expr, bbox, region = bars._get_selection_expr_for_stream_value(index=[])
+        assert expr is None
+        assert bbox is None
+        assert region is None
+
+    def test_bars_tap_no_index_kwarg(self):
+        bars = self._make_bars()
+        expr, _bbox, _region = bars._get_selection_expr_for_stream_value()
+        assert expr is None
+
+    def test_bars_box_select_categorical(self):
+        bars = self._make_bars()
+        expr, bbox, _region = bars._get_selection_expr_for_stream_value(
+            bounds=(0, 0, 2, 25), x_selection=["A", "B", "C"]
+        )
+        assert bbox == {"category": ["A", "B", "C"]}
+        assert_data_equal(
+            expr.apply(bars),
+            np.array([True, True, True, False]),
+        )
+
+    def test_bars_selection_streams_include_selection1d(self):
+        assert Selection1D in hv.Bars._selection_streams
+        assert SelectionXY in hv.Bars._selection_streams
+
+
 class TestSelection2DExpr:
     def setup_method(self):
         import holoviews.plotting.bokeh  # noqa: F401