param 2.1.0a2__tar.gz → 2.1.1a0__tar.gz

{param-2.1.0a2 → param-2.1.1a0}/PKG-INFO

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: param
-Version: 2.1.0a2
+Version: 2.1.1a0
 Summary: Make your Python code clearer and more reliable by declaring Parameters.
 Project-URL: Homepage, https://param.holoviz.org/
 Project-URL: Tracker, https://github.com/holoviz/param/issues
@@ -27,12 +27,35 @@ Classifier: Topic :: Scientific/Engineering
 Classifier: Topic :: Software Development :: Libraries
 Requires-Python: >=3.8
 Provides-Extra: all
-Requires-Dist: param[doc]; extra == 'all'
-Requires-Dist: param[lint]; extra == 'all'
-Requires-Dist: param[tests-full]; extra == 'all'
+Requires-Dist: aiohttp; extra == 'all'
+Requires-Dist: cloudpickle; extra == 'all'
+Requires-Dist: coverage[toml]; extra == 'all'
+Requires-Dist: flake8; extra == 'all'
+Requires-Dist: gmpy; extra == 'all'
+Requires-Dist: ipython; extra == 'all'
+Requires-Dist: jsonschema; extra == 'all'
+Requires-Dist: nbsite==0.8.4; extra == 'all'
+Requires-Dist: nbval; extra == 'all'
+Requires-Dist: nest-asyncio; extra == 'all'
+Requires-Dist: numpy; extra == 'all'
+Requires-Dist: odfpy; extra == 'all'
+Requires-Dist: openpyxl; extra == 'all'
+Requires-Dist: pandas; extra == 'all'
+Requires-Dist: panel; extra == 'all'
+Requires-Dist: pre-commit; extra == 'all'
+Requires-Dist: pyarrow; extra == 'all'
+Requires-Dist: pytest; extra == 'all'
+Requires-Dist: pytest-asyncio; extra == 'all'
+Requires-Dist: pytest-xdist; extra == 'all'
+Requires-Dist: pytest<8.1; extra == 'all'
+Requires-Dist: sphinx-remove-toctrees; extra == 'all'
+Requires-Dist: tables; extra == 'all'
+Requires-Dist: xlrd; extra == 'all'
 Provides-Extra: doc
+Requires-Dist: aiohttp; extra == 'doc'
 Requires-Dist: nbsite==0.8.4; extra == 'doc'
-Requires-Dist: param[examples]; extra == 'doc'
+Requires-Dist: pandas; extra == 'doc'
+Requires-Dist: panel; extra == 'doc'
 Requires-Dist: sphinx-remove-toctrees; extra == 'doc'
 Provides-Extra: examples
 Requires-Dist: aiohttp; extra == 'examples'
@@ -52,22 +75,34 @@ Requires-Dist: pyarrow; extra == 'tests-deser'
 Requires-Dist: tables; extra == 'tests-deser'
 Requires-Dist: xlrd; extra == 'tests-deser'
 Provides-Extra: tests-examples
+Requires-Dist: aiohttp; extra == 'tests-examples'
 Requires-Dist: nbval; extra == 'tests-examples'
-Requires-Dist: param[examples]; extra == 'tests-examples'
+Requires-Dist: pandas; extra == 'tests-examples'
+Requires-Dist: panel; extra == 'tests-examples'
 Requires-Dist: pytest-asyncio; extra == 'tests-examples'
 Requires-Dist: pytest-xdist; extra == 'tests-examples'
 Requires-Dist: pytest<8.1; extra == 'tests-examples'
 Provides-Extra: tests-full
+Requires-Dist: aiohttp; extra == 'tests-full'
 Requires-Dist: cloudpickle; extra == 'tests-full'
+Requires-Dist: coverage[toml]; extra == 'tests-full'
 Requires-Dist: gmpy; extra == 'tests-full'
 Requires-Dist: ipython; extra == 'tests-full'
 Requires-Dist: jsonschema; extra == 'tests-full'
+Requires-Dist: nbval; extra == 'tests-full'
 Requires-Dist: nest-asyncio; extra == 'tests-full'
 Requires-Dist: numpy; extra == 'tests-full'
+Requires-Dist: odfpy; extra == 'tests-full'
+Requires-Dist: openpyxl; extra == 'tests-full'
 Requires-Dist: pandas; extra == 'tests-full'
-Requires-Dist: param[tests-deser]; extra == 'tests-full'
-Requires-Dist: param[tests-examples]; extra == 'tests-full'
-Requires-Dist: param[tests]; extra == 'tests-full'
+Requires-Dist: panel; extra == 'tests-full'
+Requires-Dist: pyarrow; extra == 'tests-full'
+Requires-Dist: pytest; extra == 'tests-full'
+Requires-Dist: pytest-asyncio; extra == 'tests-full'
+Requires-Dist: pytest-xdist; extra == 'tests-full'
+Requires-Dist: pytest<8.1; extra == 'tests-full'
+Requires-Dist: tables; extra == 'tests-full'
+Requires-Dist: xlrd; extra == 'tests-full'
 Description-Content-Type: text/markdown
 
 <img src="https://raw.githubusercontent.com/holoviz/param/main/doc/_static/logo_horizontal.png" width=250>

{param-2.1.0a2 → param-2.1.1a0}/param/_utils.py

@@ -98,7 +98,7 @@ def _deprecate_positional_args(func):
                 f"Passing '{extra_args}' as positional argument(s) to 'param.{name}' "
                 "has been deprecated since Param 2.0.0 and will raise an error in a future version, "
                 "please pass them as keyword arguments.",
-                ParamPendingDeprecationWarning,
+                ParamDeprecationWarning,
                 stacklevel=2,
             )
 

{param-2.1.0a2 → param-2.1.1a0}/param/_version.py

@@ -12,5 +12,5 @@ __version__: str
 __version_tuple__: VERSION_TUPLE
 version_tuple: VERSION_TUPLE
 
-__version__ = version = '2.1.0a2'
-__version_tuple__ = version_tuple = (2, 1, 0)
+__version__ = version = '2.1.1a0'
+__version_tuple__ = version_tuple = (2, 1, 1)

{param-2.1.0a2 → param-2.1.1a0}/param/parameterized.py

@@ -164,11 +164,13 @@ def eval_function_with_deps(function):
             kwargs = {n: getattr(dep.owner, dep.name) for n, dep in kw_deps.items()}
     return function(*args, **kwargs)
 
-def resolve_value(value):
+def resolve_value(value, recursive=True):
     """
     Resolves the current value of a dynamic reference.
     """
-    if isinstance(value, (list, tuple)):
+    if not recursive:
+        pass
+    elif isinstance(value, (list, tuple)):
         return type(value)(resolve_value(v) for v in value)
     elif isinstance(value, dict):
         return type(value)((resolve_value(k), resolve_value(v)) for k, v in value.items())
@@ -1469,12 +1471,13 @@ class Parameter(_ParameterBase):
         item in a list).
         """
         name = self.name
-        if obj is not None and self.allow_refs and obj._param__private.initialized and name not in obj._param__private.syncing:
+        if obj is not None and self.allow_refs and obj._param__private.initialized:
+            syncing = name in obj._param__private.syncing
             ref, deps, val, is_async = obj.param._resolve_ref(self, val)
             refs = obj._param__private.refs
             if ref is not None:
                 self.owner.param._update_ref(name, ref)
-            elif name in refs:
+            elif name in refs and not syncing:
                 del refs[name]
                 if name in obj._param__private.async_refs:
                     obj._param__private.async_refs.pop(name).cancel()
@@ -2007,14 +2010,15 @@ class Parameters:
         updates = {}
         for pname, ref in self_.self._param__private.refs.items():
             # Skip updating value if dependency has not changed
-            deps = resolve_ref(ref, self_[pname].nested_refs)
+            recursive = self_[pname].nested_refs
+            deps = resolve_ref(ref, recursive)
             is_gen = inspect.isgeneratorfunction(ref)
             is_async = iscoroutinefunction(ref) or is_gen
             if not any((dep.owner is e.obj and dep.name == e.name) for dep in deps for e in events) and not is_async:
                 continue
 
             try:
-                new_val = resolve_value(ref)
+                new_val = resolve_value(ref, recursive)
             except Skip:
                 new_val = Undefined
             if new_val is Skip or new_val is Undefined:
@@ -2037,7 +2041,7 @@ class Parameters:
             return None, None, value, False
         ref = value
         try:
-            value = resolve_value(value)
+            value = resolve_value(value, recursive=pobj.nested_refs)
         except Skip:
             value = Undefined
         if is_async:
@@ -4196,13 +4200,13 @@ class Parameterized(metaclass=ParameterizedMetaclass):
 
     #PARAM3_DEPRECATION
     @property
-    @_deprecated(extra_msg="Use `inst.param.watchers` instead.", warning_cat=FutureWarning)
+    @_deprecated(extra_msg="Use `inst.param.watchers` instead.", warning_cat=_ParamFutureWarning)
     def _param_watchers(self):
         return self._param__private.watchers
 
     #PARAM3_DEPRECATION
     @_param_watchers.setter
-    @_deprecated(extra_msg="Use `inst.param.watchers = ...` instead.", warning_cat=FutureWarning)
+    @_deprecated(extra_msg="Use `inst.param.watchers = ...` instead.", warning_cat=_ParamFutureWarning)
     def _param_watchers(self, value):
         self._param__private.watchers = value
 

{param-2.1.0a2 → param-2.1.1a0}/param/reactive.py

@@ -81,6 +81,7 @@ display its repr.
 """
 from __future__ import annotations
 
+import asyncio
 import inspect
 import math
 import operator
@@ -90,19 +91,19 @@ from functools import partial
 from types import FunctionType, MethodType
 from typing import Any, Callable, Optional
 
-from . import Event
 from .depends import depends
 from .display import _display_accessors, _reactive_display_objs
 from .parameterized import (
     Parameter, Parameterized, Skip, Undefined, eval_function_with_deps, get_method_owner,
     register_reference_transform, resolve_ref, resolve_value, transform_reference
 )
-from ._utils import iscoroutinefunction, full_groupby
+from .parameters import Boolean, Event
+from ._utils import _to_async_gen, iscoroutinefunction, full_groupby
 
 
 class Wrapper(Parameterized):
     """
-    Simple wrapper to allow updating literal values easily.
+    Helper class to allow updating literal values easily.
     """
 
     object = Parameter(allow_refs=False)
@@ -110,20 +111,73 @@ class Wrapper(Parameterized):
 
 class GenWrapper(Parameterized):
     """
-    Wrapper to allow streaming from generator functions.
+    Helper class to allow streaming from generator functions.
     """
 
     object = Parameter(allow_refs=True)
 
 
 class Trigger(Parameterized):
+    """
+    Helper class to allow triggering an event under some condition.
+    """
 
     value = Event()
 
-    def __init__(self, parameters, **params):
+    def __init__(self, parameters=None, internal=False, **params):
         super().__init__(**params)
+        self.internal = internal
         self.parameters = parameters
 
+class Resolver(Parameterized):
+    """
+    Helper class to allow (recursively) resolving references.
+    """
+
+    object = Parameter(allow_refs=True)
+
+    recursive = Boolean(default=False)
+
+    value = Parameter()
+
+    def __init__(self, **params):
+        self._watchers = []
+        super().__init__(**params)
+
+    def _resolve_value(self, *events):
+        nested = self.param.object.nested_refs
+        refs = resolve_ref(self.object, nested)
+        value = resolve_value(self.object, nested)
+        if self.recursive:
+            new_refs = [r for r in resolve_ref(value, nested) if r not in refs]
+            while new_refs:
+                refs += new_refs
+                value = resolve_value(value, nested)
+                new_refs = [r for r in resolve_ref(value, nested) if r not in refs]
+            if events:
+                self._update_refs(refs)
+        self.value = value
+        return refs
+
+    @depends('object', watch=True, on_init=True)
+    def _resolve_object(self):
+        refs = self._resolve_value()
+        self._update_refs(refs)
+
+    def _update_refs(self, refs):
+        for w in self._watchers:
+            (w.inst or w.cls).param.unwatch(w)
+        self._watchers = []
+        for _, params in full_groupby(refs, lambda x: id(x.owner)):
+            self._watchers.append(
+                params[0].owner.param.watch(self._resolve_value, [p.name for p in params])
+            )
+
+
+class NestedResolver(Resolver):
+
+    object = Parameter(allow_refs=True, nested_refs=True)
+
 
 class reactive_ops:
     """
@@ -204,8 +258,17 @@ class reactive_ops:
         kwargs: mapping, optional
           A dictionary of keywords to pass to `func`.
         """
-        def apply(vs, *args, **kwargs):
-            return [func(v, *args, **kwargs) for v in vs]
+        if inspect.isasyncgenfunction(func) or inspect.isgeneratorfunction(func):
+            raise TypeError(
+                "Cannot map a generator function. Only regular function "
+                "or coroutine functions are permitted."
+            )
+        if inspect.iscoroutinefunction(func):
+            async def apply(vs, *args, **kwargs):
+                return list(await asyncio.gather(*(func(v, *args, **kwargs) for v in vs)))
+        else:
+            def apply(vs, *args, **kwargs):
+                return [func(v, *args, **kwargs) for v in vs]
         return self._as_rx()._apply_operator(apply, *args, **kwargs)
 
     def not_(self):
@@ -235,6 +298,27 @@ class reactive_ops:
         """
         return self._as_rx()._apply_operator(func, *args, **kwargs)
 
+    def resolve(self, nested=True, recursive=False):
+        """
+        Resolves references held by the expression.
+
+        As an example if the expression returns a list of parameters
+        this operation will return a list of the parameter values.
+
+        Arguments
+        ---------
+        nested: bool
+          Whether to resolve references contained within nested objects,
+          i.e. tuples, lists, sets and dictionaries.
+        recursive: bool
+          Whether to recursively resolve references, i.e. if a reference
+          itself returns a reference we recurse into it until no more
+          references can be resolved.
+        """
+        resolver_type = NestedResolver if nested else Resolver
+        resolver = resolver_type(object=self._reactive, recursive=recursive)
+        return resolver.param.value.rx()
+
     def updating(self):
         """
         Returns a new expression that is True while the expression is updating.
@@ -646,19 +730,27 @@ class rx:
         self._depth = depth
         self._dirty = _current is None
         self._dirty_obj = False
+        self._current_task = None
         self._error_state = None
         self._current_ = _current
         if isinstance(obj, rx) and not prev:
             self._prev = obj
         else:
             self._prev = prev
+
+        # Define special trigger parameter if operation has to be lazily evaluated
+        if operation and (iscoroutinefunction(operation['fn']) or inspect.isgeneratorfunction(operation['fn'])):
+            self._trigger = Trigger(internal=True)
+            self._current_ = Undefined
+        else:
+            self._trigger = None
         self._root = self._compute_root()
         self._fn_params = self._compute_fn_params()
         self._internal_params = self._compute_params()
         # Filter params that external objects depend on, ensuring
         # that Trigger parameters do not cause double execution
         self._params = [
-            p for p in self._internal_params if not isinstance(p.owner, Trigger)
+            p for p in self._internal_params if (not isinstance(p.owner, Trigger) or p.owner.internal)
             or any (p not in self._internal_params for p in p.owner.parameters)
         ]
         self._setup_invalidations(depth)
@@ -721,7 +813,9 @@ class rx:
         return args + kwargs
 
     def _compute_params(self) -> list[Parameter]:
-        ps = self._fn_params
+        ps = list(self._fn_params)
+        if self._trigger:
+            ps.append(self._trigger.param.value)
 
         # Collect parameters on previous objects in chain
         prev = self._prev
@@ -735,6 +829,9 @@ class rx:
             return ps
 
         # Accumulate dependencies in args and/or kwargs
+        for ref in resolve_ref(self._operation['fn']):
+            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):
                 if ref not in ps:
@@ -763,11 +860,15 @@ class rx:
         """
         if self._fn is not None:
             for _, params in full_groupby(self._fn_params, lambda x: id(x.owner)):
-                params[0].owner.param._watch(self._invalidate_obj, [p.name for p in params], precedence=-1)
+                fps = [p.name for p in params if p in self._root._fn_params]
+                if fps:
+                    params[0].owner.param._watch(self._invalidate_obj, fps, precedence=-1)
         for _, params in full_groupby(self._internal_params, lambda x: id(x.owner)):
             params[0].owner.param._watch(self._invalidate_current, [p.name for p in params], precedence=-1)
 
     def _invalidate_current(self, *events):
+        if all(event.obj is self._trigger for event in events):
+            return
         self._dirty = True
         self._error_state = None
 
@@ -775,6 +876,26 @@ class rx:
         self._root._dirty_obj = True
         self._error_state = None
 
+    async def _resolve_async(self, obj):
+        self._current_task = task = asyncio.current_task()
+        if inspect.isasyncgen(obj):
+            async for val in obj:
+                if self._current_task is not task:
+                    break
+                self._current_ = val
+                self._trigger.param.trigger('value')
+        else:
+            value = await obj
+            if self._current_task is task:
+                self._current_ = value
+                self._trigger.param.trigger('value')
+
+    def _lazy_resolve(self, obj):
+        from .parameterized import async_executor
+        if inspect.isgenerator(obj):
+            obj = _to_async_gen(obj)
+        async_executor(partial(self._resolve_async, obj))
+
     def _resolve(self):
         if self._error_state:
             raise self._error_state
@@ -787,9 +908,13 @@ class rx:
                 operation = self._operation
                 if operation:
                     obj = self._eval_operation(obj, operation)
+                    if inspect.isasyncgen(obj) or inspect.iscoroutine(obj) or inspect.isgenerator(obj):
+                        self._lazy_resolve(obj)
+                        obj = Skip
                     if obj is Skip:
                         raise Skip
             except Skip:
+                self._dirty = False
                 return self._current_
             except Exception as e:
                 self._error_state = e

{param-2.1.0a2 → param-2.1.1a0}/tests/testdeprecations.py

@@ -22,7 +22,7 @@ def specific_filter():
 class TestDeprecateParameter:
 
     def test_deprecate_posargs_Parameter(self):
-        with pytest.raises(param._utils.ParamPendingDeprecationWarning):
+        with pytest.raises(param._utils.ParamDeprecationWarning):
             param.Parameter(1, 'doc')
 
     def test_deprecate_List_class_(self):
@@ -103,11 +103,11 @@ class TestDeprecateParameterizedModule:
             param.parameterized.all_equal(1, 1)
 
     def test_deprecate_param_watchers(self):
-        with pytest.raises(FutureWarning):
+        with pytest.raises(param._utils.ParamFutureWarning):
             param.parameterized.Parameterized()._param_watchers
 
     def test_deprecate_param_watchers_setter(self):
-        with pytest.raises(FutureWarning):
+        with pytest.raises(param._utils.ParamFutureWarning):
             param.parameterized.Parameterized()._param_watchers = {}
 
     def test_param_error_unsafe_ops_before_initialized(self):

{param-2.1.0a2 → param-2.1.1a0}/tests/testreactive.py

@@ -27,6 +27,8 @@ import pytest
 from param.parameterized import Skip
 from param.reactive import bind, rx
 
+from .utils import async_wait_until
+
 NUMERIC_BINARY_OPERATORS = (
     operator.add, divmod, operator.floordiv, operator.mod, operator.mul,
     operator.pow, operator.sub, operator.truediv,
@@ -67,6 +69,8 @@ class Parameters(param.Parameterized):
 
     boolean = param.Boolean(default=False)
 
+    parameter = param.Parameter(allow_refs=False)
+
     event = param.Event()
 
     @param.depends('integer')
@@ -305,6 +309,19 @@ def test_reactive_map():
     i.rx.value = range(1, 4)
     assert b.rx.value == [2, 4, 6]
 
+async def test_reactive_async_map():
+    i = rx(range(3))
+    async def mul(x):
+        await asyncio.sleep(0.05)
+        return x*2
+    b = i.rx.map(mul)
+    assert b.rx.value is param.Undefined
+    await async_wait_until(lambda: b.rx.value == [0, 2, 4])
+    i.rx.value = range(1, 4)
+    assert b.rx.value == [0, 2, 4]
+    await async_wait_until(lambda: b.rx.value == [2, 4, 6])
+    assert b.rx.value == [2, 4, 6]
+
 def test_reactive_map_args():
     i = rx(range(3))
     j = rx(2)
@@ -393,11 +410,7 @@ async def test_reactive_watch_async_on_event():
     items = []
     event.rx.watch(items.append)
     p.param.trigger('event')
-    for _ in range(3):
-        await asyncio.sleep(0.05)
-        if items == [True]:
-            break
-    assert items == [True]
+    await async_wait_until(lambda: items == [True])
 
 def test_reactive_set_value_non_root_raises():
     rx_val = rx(1) + 1
@@ -433,6 +446,96 @@ def test_reactive_when_initial():
     p.param.trigger('event')
     assert integer.rx.value == 4
 
+def test_reactive_resolve():
+    p = Parameters(integer=3)
+    p2 = Parameters(parameter=p.param.integer)
+
+    prx = p2.param.parameter.rx()
+    assert prx.rx.value is p.param.integer
+
+    resolved_prx = prx.rx.resolve()
+    assert resolved_prx.rx.value == 3
+
+    changes = []
+    resolved_prx.rx.watch(changes.append)
+
+    # Test changing referenced value
+    p.integer = 4
+    assert resolved_prx.rx.value == 4
+    assert changes == [4]
+
+    # Test changing reference itself
+    p2.parameter = p.param.number
+    assert resolved_prx.rx.value == 3.14
+    assert changes == [4, 3.14]
+
+    # Ensure no updates triggered when old reference is updated
+    p.integer = 5
+    assert resolved_prx.rx.value == 3.14
+    assert changes == [4, 3.14]
+
+def test_reactive_resolve_nested():
+    p = Parameters(integer=3)
+    p2 = Parameters(parameter=[p.param.integer])
+
+    prx = p2.param.parameter.rx()
+    assert prx.rx.value == [p.param.integer]
+
+    resolved_prx = prx.rx.resolve(nested=True)
+    assert resolved_prx.rx.value == [3]
+
+    changes = []
+    resolved_prx.rx.watch(changes.append)
+
+    # Test changing referenced value
+    p.integer = 4
+    assert resolved_prx.rx.value == [4]
+    assert changes == [[4]]
+
+    # Test changing reference itself
+    p2.parameter = [p.param.number]
+    assert resolved_prx.rx.value == [3.14]
+    assert changes == [[4], [3.14]]
+
+    # Ensure no updates triggered when old reference is updated
+    p.integer = 5
+    assert resolved_prx.rx.value == [3.14]
+    assert changes == [[4], [3.14]]
+
+def test_reactive_resolve_recursive():
+    p = Parameters(integer=3)
+    p2 = Parameters(parameter=p.param.integer)
+    p3 = Parameters(parameter=p2.param.parameter)
+
+    prx = p3.param.parameter.rx()
+    assert prx.rx.value is p2.param.parameter
+
+    resolved_prx = prx.rx.resolve(recursive=True)
+    assert resolved_prx.rx.value == 3
+
+    changes = []
+    resolved_prx.rx.watch(changes.append)
+
+    # Test changing referenced value
+    p.integer = 4
+    assert resolved_prx.rx.value == 4
+    assert changes == [4]
+
+    # Test changing recursive reference
+    p2.parameter = p.param.number
+    assert resolved_prx.rx.value == 3.14
+    assert changes == [4, 3.14]
+
+    # Ensure no updates triggered when old reference is updated
+    p.integer = 5
+    assert resolved_prx.rx.value == 3.14
+    assert changes == [4, 3.14]
+
+    # Test changing reference itself
+    p3.parameter = p.param.string
+    assert resolved_prx.rx.value == 'string'
+    assert changes == [4, 3.14, 'string']
+
 async def test_reactive_async_func():
     async def async_func():
         await asyncio.sleep(0.02)
@@ -440,8 +543,17 @@ async def test_reactive_async_func():
 
     async_rx = rx(async_func) + 2
     assert async_rx.rx.value is param.Undefined
-    await asyncio.sleep(0.04)
-    assert async_rx.rx.value == 4
+    await async_wait_until(lambda: async_rx.rx.value == 4)
+
+async def test_reactive_pipe_async_func():
+    async def async_func(value):
+        await asyncio.sleep(0.02)
+        return value+2
+
+    async_rx = rx(0).rx.pipe(async_func)
+    async_rx.rx.watch()
+    assert async_rx.rx.value is param.Undefined
+    await async_wait_until(lambda: async_rx.rx.value == 2)
 
 async def test_reactive_gen():
     def gen():
@@ -453,11 +565,25 @@ async def test_reactive_gen():
     assert rxgen.rx.value is param.Undefined
     await asyncio.sleep(0.04)
     assert rxgen.rx.value == 1
-    for _ in range(3):
-        await asyncio.sleep(0.05)
-        if rxgen.rx.value == 2:
-            break
-    assert rxgen.rx.value == 2
+    await async_wait_until(lambda: rxgen.rx.value == 2)
+
+async def test_reactive_gen_pipe():
+    def gen(val):
+        yield val+1
+        time.sleep(0.05)
+        yield val+2
+
+    rxv = rx(0)
+    rxgen = rxv.rx.pipe(gen)
+    rxgen.rx.watch()
+    assert rxgen.rx.value is param.Undefined
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 1
+    await async_wait_until(lambda: rxgen.rx.value == 2)
+    rxv.rx.value = 2
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 3
+    await async_wait_until(lambda: rxgen.rx.value == 4)
 
 async def test_reactive_gen_with_dep():
     def gen(i):
@@ -473,24 +599,53 @@ async def test_reactive_gen_with_dep():
     irx.rx.value = 3
     await asyncio.sleep(0.04)
     assert rxgen.rx.value == 4
-    for _ in range(3):
-        await asyncio.sleep(0.05)
-        if rxgen.rx.value == 5:
-            break
-    assert rxgen.rx.value == 5
+    await async_wait_until(lambda: rxgen.rx.value == 5)
+
+async def test_reactive_gen_pipe_with_dep():
+    def gen(value, i):
+        yield value+i+1
+        time.sleep(0.05)
+        yield value+i+2
+
+    irx = rx(0)
+    rxv = rx(0)
+    rxgen = rxv.rx.pipe(bind(gen, irx))
+    rxgen.rx.watch()
+    assert rxgen.rx.value is param.Undefined
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 1
+    irx.rx.value = 3
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 4
+    await async_wait_until(lambda: rxgen.rx.value == 5)
+    rxv.rx.value = 5
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 9
+    await async_wait_until(lambda: rxgen.rx.value == 10)
 
 async def test_reactive_async_gen():
     async def gen():
         yield 1
-        await asyncio.sleep(0.1)
+        await asyncio.sleep(0.05)
         yield 2
 
     rxgen = rx(gen)
     assert rxgen.rx.value is param.Undefined
-    await asyncio.sleep(0.05)
+    await asyncio.sleep(0.04)
     assert rxgen.rx.value == 1
-    await asyncio.sleep(0.1)
-    assert rxgen.rx.value == 2
+    await async_wait_until(lambda: rxgen.rx.value == 2)
+
+async def test_reactive_async_gen_pipe():
+    async def gen(value):
+        yield value + 1
+        await asyncio.sleep(0.05)
+        yield value + 2
+
+    rxgen = rx(0).rx.pipe(gen)
+    assert rxgen.rx.value is param.Undefined
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 1
+    await async_wait_until(lambda: rxgen.rx.value == 2)
 
 async def test_reactive_async_gen_with_dep():
     async def gen(i):
@@ -508,3 +663,81 @@ async def test_reactive_async_gen_with_dep():
     irx.rx.value = 4
     await asyncio.sleep(0.1)
     assert rxgen.rx.value == 5
+
+async def test_reactive_async_gen_pipe_with_dep():
+    async def gen(value, i):
+        yield value+i+1
+        await asyncio.sleep(0.05)
+        yield value+i+2
+
+    irx = rx(0)
+    rxv = rx(0)
+    rxgen = rxv.rx.pipe(bind(gen, i=irx))
+    rxgen.rx.watch()
+    assert rxgen.rx.value is param.Undefined
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 1
+    irx.rx.value = 3
+    await asyncio.sleep(0.04)
+    irx.rx.value = 4
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 5
+    rxv.rx.value = 5
+    await asyncio.sleep(0.04)
+    assert rxgen.rx.value == 10
+    await async_wait_until(lambda: rxgen.rx.value == 11)
+
+def test_root_invalidation():
+    arx = rx('a')
+    brx = rx('b')
+
+    computed = []
+    def debug(value, info):
+        computed.append(info)
+        return value
+
+    expr = arx.title().rx.pipe(debug, '1') + brx.title().rx.pipe(debug, '2')
+
+    assert expr.rx.value == 'AB'
+    assert computed == ['1', '2']
+
+    brx.rx.value = 'c'
+
+    assert expr.rx.value == 'AC'
+    assert computed == ['1', '2', '2']
+
+    arx.rx.value = 'd'
+    assert expr.rx.value == 'DC'
+    assert computed == ['1', '2', '2', '1']
+
+
+def test_ensure_ref_can_update_by_watcher_of_same_parameter():
+    # https://github.com/holoviz/param/pull/929
+
+    class W(param.Parameterized):
+        value = param.String()
+
+
+    class T(param.Parameterized):
+        lst = param.List(allow_refs=True, allow_None=True)
+
+        @param.depends("lst", watch=True)
+        def test(self):
+            lst = self.lst or range(5)
+            items = [W(value=str(i)) for i in lst]
+            with param.discard_events(self):
+                self.lst = param.rx(items).rx.resolve()
+            self.items = items
+
+    def transform(obj):
+        if isinstance(obj, W):
+            return obj.param.value
+        return obj
+
+
+    param.reactive.register_reference_transform(transform)
+
+    t = T()
+    t.lst = list("ABCDE")
+    t.items[1].value = "TEST"
+    assert t.lst[1] == "TEST"

{param-2.1.0a2 → param-2.1.1a0}/tests/testsignatures.py

@@ -97,17 +97,17 @@ def test_signature_position_keywords():
 def test_signature_warning_by_position():
     # Simple test as it's tricky to automatically test all the Parameters
     with pytest.warns(
-        param._utils.ParamPendingDeprecationWarning,
+        param._utils.ParamDeprecationWarning,
         match=r"Passing 'objects' as positional argument\(s\) to 'param.Selector' has been deprecated since Param 2.0.0 and will raise an error in a future version, please pass them as keyword arguments"
     ):
         param.Selector([0, 1])  # objects
     with pytest.warns(
-        param._utils.ParamPendingDeprecationWarning,
+        param._utils.ParamDeprecationWarning,
         match=r"Passing 'class_' as positional argument\(s\) to 'param.ClassSelector' has been deprecated since Param 2.0.0 and will raise an error in a future version, please pass them as keyword arguments"
     ):
         param.ClassSelector(int)  # class_
     with pytest.warns(
-        param._utils.ParamPendingDeprecationWarning,
+        param._utils.ParamDeprecationWarning,
         match=r"Passing 'bounds, softbounds' as positional argument\(s\) to 'param.Number' has been deprecated since Param 2.0.0 and will raise an error in a future version, please pass them as keyword arguments"
     ):
         param.Number(1, (0, 2), (0, 2))  # default (OK), bounds (not OK), softbounds (not OK)

{param-2.1.0a2 → param-2.1.1a0}/tests/testwatch.py

@@ -652,7 +652,7 @@ class TestWatch(unittest.TestCase):
 
         obj.param.watch(lambda: '', ['a', 'b'])
 
-        with pytest.warns(FutureWarning):
+        with pytest.warns(param._utils.ParamFutureWarning):
             pw = obj._param_watchers
         assert isinstance(pw, dict)
         for pname in ('a', 'b'):
@@ -667,7 +667,7 @@ class TestWatch(unittest.TestCase):
 
         obj.param.watch(accumulator, ['a', 'b'])
 
-        with pytest.warns(FutureWarning):
+        with pytest.warns(param._utils.ParamFutureWarning):
             pw = obj._param_watchers
         del pw['a']
 

{param-2.1.0a2 → param-2.1.1a0}/tests/utils.py

@@ -1,4 +1,6 @@
+import asyncio
 import logging
+import time
 
 from contextlib import contextmanager
 
@@ -111,3 +113,64 @@ def warnings_as_excepts(match=None):
             raise ValueError(f'Exception emitted {str(e)!r} does not contain {match!r}')
     finally:
         param.parameterized.warnings_as_exceptions = orig
+
+
+async def async_wait_until(fn, timeout=5000, interval=100):
+    """
+    Exercise a test function in a loop until it evaluates to True
+    or times out.
+
+    The function can either be a simple lambda that returns True or False:
+    >>> await async_wait_until(lambda: x.values() == ['x'])
+
+    Or a defined function with an assert:
+    >>> async def _()
+    >>>    assert x.values() == ['x']
+    >>> await async_wait_until(_)
+
+    Parameters
+    ----------
+    fn : callable
+        Callback
+    timeout : int, optional
+        Total timeout in milliseconds, by default 5000
+    interval : int, optional
+        Waiting interval, by default 100
+
+    Adapted from pytest-qt.
+    """
+    # Hide this function traceback from the pytest output if the test fails
+    __tracebackhide__ = True
+
+    start = time.monotonic()
+
+    def timed_out():
+        elapsed = time.monotonic() - start
+        elapsed_ms = elapsed * 1000
+        return elapsed_ms > timeout
+
+    timeout_msg = f"async_wait_until timed out in {timeout} milliseconds"
+
+    while True:
+        try:
+            result = fn()
+            if asyncio.iscoroutine(result):
+                result = await result
+        except AssertionError as e:
+            if timed_out():
+                raise TimeoutError(timeout_msg) from e
+        else:
+            if result not in (None, True, False):
+                raise ValueError(
+                    "`async_wait_until` callback must return None, True, or "
+                    f"False, returned {result!r}"
+                )
+            # None is returned when the function has an assert
+            if result is None:
+                return
+            # When the function returns True or False
+            if result:
+                return
+            if timed_out():
+                raise TimeoutError(timeout_msg)
+        await asyncio.sleep(interval / 1000)