Recursively resolve references on args and kwargs passed to an reactive operation

param/parameterized.py

@@ -196,11 +196,11 @@ def resolve_ref(reference, recursive=False):
     """
     if recursive:
         if isinstance(reference, (list, tuple, set)):
-            return [r for v in reference for r in resolve_ref(v)]
+            return [r for v in reference for r in resolve_ref(v, recursive)]
         elif isinstance(reference, dict):
-            return [r for kv in reference.items() for o in kv for r in resolve_ref(o)]
+            return [r for kv in reference.items() for o in kv for r in resolve_ref(o, recursive)]
         elif isinstance(reference, slice):
-            return [r for v in (reference.start, reference.stop, reference.step) for r in resolve_ref(v)]
+            return [r for v in (reference.start, reference.stop, reference.step) for r in resolve_ref(v, recursive)]
     reference = transform_reference(reference)
     if hasattr(reference, '_dinfo'):
         dinfo = getattr(reference, '_dinfo', {})

param/reactive.py

@@ -833,7 +833,7 @@ def _compute_params(self) -> list[Parameter]:
             if ref not in ps:
                 ps.append(ref)
         for arg in list(self._operation['args'])+list(self._operation['kwargs'].values()):
-            for ref in resolve_ref(arg):
+            for ref in resolve_ref(arg, recursive=True):
                 if ref not in ps:
                     ps.append(ref)
 

tests/testreactive.py

@@ -125,6 +125,26 @@ def test_reactive_getitem_list():
     assert rx([1, 2, 3])[1].rx.value == 2
     assert rx([1, 2, 3])[2].rx.value == 3
 
+def test_reactive_getitem_list_with_slice():
+    i = rx(1)
+    j = rx(5)
+    lst = list(range(10))
+    lstx = rx(lst)
+    sx = lstx[i: j]
+    assert sx.rx.value == lst[i.rx.value: j.rx.value]
+    i.rx.value = 2
+    assert sx.rx.value == lst[i.rx.value: j.rx.value]
+
+def test_reactive_getitem_numpy_with_tuple():
+    i = rx(0)
+    j = rx(1)
+    arr = np.array([[1, 2, 3], [4, 5, 6], [7, 8, 9]])
+    arrx = rx(arr)
+    selx = arrx[i, j]
+    assert selx.rx.value == arr[i.rx.value, j.rx.value]
+    i.rx.value = 1
+    assert selx.rx.value == arr[i.rx.value, j.rx.value]
+
 @pytest.mark.parametrize('ufunc', NUMPY_UFUNCS)
 def test_numpy_ufunc(ufunc):
     l = [1, 2, 3]

tests/testrefs.py

@@ -5,7 +5,7 @@
 import param
 import pytest
 
-from param.parameterized import Skip
+from param.parameterized import Skip, resolve_ref
 from param.reactive import bind, rx
 
 class Parameters(param.Parameterized):
@@ -286,3 +286,50 @@ def gen_strings2():
     assert task1.done()
     assert not task2.done()
     assert len(threads) == 2
+
+def test_resolve_ref_parameter():
+    p = Parameters()
+    refs = resolve_ref(p.param.string)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string
+
+def test_resolve_ref_depends_method():
+    p = Parameters()
+    refs = resolve_ref(p.formatted_string)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string
+
+def test_resolve_ref_recursive_list():
+    p = Parameters()
+    nested = [[p.param.string]]
+    refs = resolve_ref(nested, recursive=True)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string
+
+def test_resolve_ref_recursive_set():
+    p = Parameters()
+    nested = {(p.param.string,)}  # Parameters aren't hashable
+    refs = resolve_ref(nested, recursive=True)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string
+
+def test_resolve_ref_recursive_tuple():
+    p = Parameters()
+    nested = ((p.param.string,),)
+    refs = resolve_ref(nested, recursive=True)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string
+
+def test_resolve_ref_recursive_dict():
+    p = Parameters()
+    nested = {'0': {'0': p.param.string}}
+    refs = resolve_ref(nested, recursive=True)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string
+
+def test_resolve_ref_recursive_slice():
+    p = Parameters()
+    nested = [slice(p.param.string)]
+    refs = resolve_ref(nested, recursive=True)
+    assert len(refs) == 1
+    assert refs[0] is p.param.string