fix: Handle NdMapping with explicit tuple set slicing with dimension values (#6780)

Author: hoxbro

holoviews/core/ndmapping.py

@@ -227,6 +227,12 @@ def _split_index(self, key):
         elif key == ():
             return (), ()
 
+        # If a single set/list of full-key tuples, expand into per-dimension sets
+        if len(key) == 1 and isinstance(key[0], (set, list)) and len(key[0]) > 0:
+            items = list(key[0])
+            if all(isinstance(item, tuple) and len(item) == self.ndims for item in items):
+                key = tuple([item[i] for item in items] for i in range(self.ndims))
+
         if key[0] is Ellipsis:
             num_pad = self.ndims - len(key) + 1
             key = (slice(None),) * num_pad + key[1:]

holoviews/core/spaces.py

@@ -1242,6 +1242,8 @@ def _cross_product(self, tuple_key, cache, data_slice):
                 val = cache[key]
             else:
                 val = self._execute_callback(*key)
+                if not self.unbounded:
+                    self._cache(key, val)
             if data_slice:
                 val = self._dataslice(val, data_slice)
             data.append((key, val))

holoviews/tests/core/test_dynamic.py

@@ -496,6 +496,40 @@ def cb(i):
         with pytest.raises(KeyError):
             dmaps[1][1]
 
+    @pytest.mark.parametrize(
+        ("kdims", "keys"),
+        [
+            ([hv.Dimension("x", values=[1, 2]), "y"], {(1, 0.5)}),
+            ([hv.Dimension("x", values=["1", "2"]), "y"], {("1", 0.5)}),
+            ([hv.Dimension("x", range=(1, 5)), "y"], {(1, 0.5)}),
+            (
+                [hv.Dimension("x", values=[1, 2]), hv.Dimension("y", values=[3, 4])],
+                {(1, 3), (2, 4)},
+            ),
+        ],
+        ids=["int_values", "str_values", "no_values", "multi_key"],
+    )
+    def test_explicit_tuple_set_slicing(self, kdims, keys):
+        call_count = 0
+
+        def callback(x, y):
+            nonlocal call_count
+            call_count += 1
+            return hv.Curve([x, y])
+
+        dmap = hv.DynamicMap(callback, kdims=kdims)
+        assert call_count == 0
+        result = dmap[keys]
+        assert len(result) == len(keys)
+        for key in keys:
+            assert key in result.data
+
+        assert call_count == len(keys)
+
+        # Check we hit cache
+        result = dmap[keys]
+        assert call_count == len(keys)
+
 
 class DynamicMapOptionsTests(CustomBackendTestCase):
     def test_dynamic_options(self):

holoviews/tests/core/test_ndmapping.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 import numpy as np
+import pytest
 
 import holoviews as hv
 from holoviews.core.ndmapping import MultiDimensionalMapping, UniformNdMapping
@@ -127,6 +128,35 @@ def test_ndmapping_slice_upper_bound_exclusive2_float(self):
         ndmap = hv.NdMapping(self.init_item_odict, kdims=[self.dim1, self.dim2])
         assert ndmap[:, 0.0:3.0].keys() == [(1, 2.0)]
 
+    @pytest.mark.parametrize(
+        ("kdims", "data", "keys"),
+        [
+            ([hv.Dimension("x", values=[1, 2]), "y"], {(1, 0.5): "a", (2, 0.5): "b"}, {(1, 0.5)}),
+            (
+                [hv.Dimension("x", values=["1", "2"]), "y"],
+                {("1", 0.5): "a", ("2", 0.5): "b"},
+                {("1", 0.5)},
+            ),
+            (
+                ["x", hv.Dimension("y", values=[0.5, 1.5])],
+                {(1, 0.5): "a", (1, 1.5): "b"},
+                {(1, 0.5)},
+            ),
+            (
+                [hv.Dimension("x", values=[1, 2]), "y"],
+                {(1, 0.5): "a", (2, 0.5): "b"},
+                {(1, 0.5), (2, 0.5)},
+            ),
+        ],
+        ids=["int_values_first", "str_values_first", "int_values_on_second", "multi_key"],
+    )
+    def test_explicit_tuple_set_slicing(self, kdims, data, keys):
+        ndmap = hv.NdMapping(data, kdims=kdims)
+        result = ndmap[keys]
+        assert len(result) == len(keys)
+        for key in keys:
+            assert key in result.data
+
     def test_idxmapping_unsorted(self):
         data = [("B", 1), ("C", 2), ("A", 3)]
         ndmap = MultiDimensionalMapping(data, sort=False)