param 2.1.0a2__tar.gz → 2.1.1__tar.gz

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

@@ -1,6 +1,6 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.3
 Name: param
-Version: 2.1.0a2
+Version: 2.1.1
 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,34 @@ 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: 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 +74,33 @@ 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; 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: 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.1}/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.1}/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.1'
+__version_tuple__ = version_tuple = (2, 1, 1)

{param-2.1.0a2 → param-2.1.1}/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())
@@ -194,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', {})
@@ -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:
@@ -2100,7 +2104,7 @@ class Parameters:
 
         dict_[key] = new_object
 
-        if isinstance(new_object, Parameterized):
+        if isinstance(new_object, Parameterized) and deepcopy:
             global object_count
             object_count += 1
             # Writes over name given to the original object;
@@ -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.1}/param/parameters.py

@@ -2150,7 +2150,7 @@ class MultiFileSelector(ListSelector):
 
 class ClassSelector(SelectorBase):
     """
-    Parameter allowing selection of either a subclass or an instance of a given set of classes.
+    Parameter allowing selection of either a subclass or an instance of a class or tuple of classes.
     By default, requires an instance, but if is_instance=False, accepts a class instead.
     Both class and instance values respect the instantiate slot, though it matters only
     for is_instance=True.

{param-2.1.0a2 → param-2.1.1}/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:
     """
@@ -157,7 +211,7 @@ class reactive_ops:
 
     def buffer(self, n):
         """
-        Collects the last n items that were emmitted.
+        Collects the last n items that were emitted.
         """
         items = []
         def collect(new, n):
@@ -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,8 +829,11 @@ 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):
+            for ref in resolve_ref(arg, recursive=True):
                 if ref not in ps:
                     ps.append(ref)
 
@@ -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
@@ -829,7 +954,10 @@ class rx:
     def _callback(self):
         params = self._params
         def evaluate(*args, **kwargs):
-            return self._transform_output(self._current)
+            out = self._current
+            if self._method:
+                out = getattr(out, self._method)
+            return self._transform_output(out)
         if params:
             return bind(evaluate, *params)
         return evaluate

{param-2.1.0a2 → param-2.1.1}/pyproject.toml

@@ -57,7 +57,7 @@ tests-deser = [
     "tables",
 ]
 tests-examples = [
-    "pytest <8.1",  # https://github.com/computationalmodelling/nbval/issues/202
+    "pytest",
     "pytest-asyncio",
     "pytest-xdist",
     "nbval",
@@ -210,6 +210,7 @@ python = [
     "3.9",
     "3.10",
     "3.11",
+    "3.12",
 ]
 
 [tool.hatch.envs.tests_examples.scripts]

{param-2.1.0a2 → param-2.1.1}/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.1}/tests/testparameterizedobject.py

@@ -833,6 +833,26 @@ class TestParameterized(unittest.TestCase):
         assert t.inst == 'foo'
         assert t.notinst == 1
 
+    def test_constant_readonly_parameterized(self):
+        class ParamClass(param.Parameterized):
+            x = param.Number()
+
+        pc1 = ParamClass(name="FOO1")
+        pc2 = ParamClass(name="FOO2")
+
+        class P(param.Parameterized):
+            ro = param.Parameter(pc1, constant=True)
+            const = param.Parameter(pc2, readonly=True)
+            ro_i = param.Parameter(pc1, constant=True, instantiate=True)
+            const_i = param.Parameter(pc2, readonly=True, instantiate=True)
+
+        p = P()
+
+        assert p.ro.name == 'FOO1'
+        assert p.const.name == 'FOO2'
+        assert p.ro_i.name.startswith('ParamClass0')
+        assert p.const_i.name == 'FOO2'
+
 
 class some_fn(param.ParameterizedFunction):
     __test__ = False