param 2.0.2rc1__tar.gz → 2.1.0a2__tar.gz

{param-2.0.2rc1 → param-2.1.0a2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: param
-Version: 2.0.2rc1
+Version: 2.1.0a2
 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
@@ -54,9 +54,9 @@ Requires-Dist: xlrd; extra == 'tests-deser'
 Provides-Extra: tests-examples
 Requires-Dist: nbval; extra == 'tests-examples'
 Requires-Dist: param[examples]; 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: cloudpickle; extra == 'tests-full'
 Requires-Dist: gmpy; extra == 'tests-full'
@@ -74,7 +74,7 @@ Description-Content-Type: text/markdown
 
 |    |    |
 | --- | --- |
-| Build Status | [![Linux/MacOS/Windows Build Status](https://github.com/holoviz/param/workflows/pytest/badge.svg)](https://github.com/holoviz/param/actions/workflows/test.yml)
+| Build Status | [![Linux/MacOS/Windows Build Status](https://github.com/holoviz/param/workflows/tests/badge.svg)](https://github.com/holoviz/param/actions/workflows/test.yaml)
 | Coverage | [![codecov](https://codecov.io/gh/holoviz/param/branch/main/graph/badge.svg)](https://codecov.io/gh/holoviz/param) ||
 | Latest dev release | [![Github tag](https://img.shields.io/github/v/tag/holoviz/param.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/param/tags) [![dev-site](https://img.shields.io/website-up-down-green-red/https/holoviz-dev.github.io/param.svg?label=dev%20website)](https://holoviz-dev.github.io/param/) |
 | Latest release | [![Github release](https://img.shields.io/github/release/holoviz/param.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/param/releases) [![PyPI version](https://img.shields.io/pypi/v/param.svg?colorB=cc77dd)](https://pypi.python.org/pypi/param) [![param version](https://img.shields.io/conda/v/pyviz/param.svg?colorB=4488ff&style=flat)](https://anaconda.org/pyviz/param) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/param.svg?label=conda%7Cconda-forge&colorB=4488ff)](https://anaconda.org/conda-forge/param) [![defaults version](https://img.shields.io/conda/v/anaconda/param.svg?label=conda%7Cdefaults&style=flat&colorB=4488ff)](https://anaconda.org/anaconda/param) |

{param-2.0.2rc1 → param-2.1.0a2}/README.md

@@ -2,7 +2,7 @@
 
 |    |    |
 | --- | --- |
-| Build Status | [![Linux/MacOS/Windows Build Status](https://github.com/holoviz/param/workflows/pytest/badge.svg)](https://github.com/holoviz/param/actions/workflows/test.yml)
+| Build Status | [![Linux/MacOS/Windows Build Status](https://github.com/holoviz/param/workflows/tests/badge.svg)](https://github.com/holoviz/param/actions/workflows/test.yaml)
 | Coverage | [![codecov](https://codecov.io/gh/holoviz/param/branch/main/graph/badge.svg)](https://codecov.io/gh/holoviz/param) ||
 | Latest dev release | [![Github tag](https://img.shields.io/github/v/tag/holoviz/param.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/param/tags) [![dev-site](https://img.shields.io/website-up-down-green-red/https/holoviz-dev.github.io/param.svg?label=dev%20website)](https://holoviz-dev.github.io/param/) |
 | Latest release | [![Github release](https://img.shields.io/github/release/holoviz/param.svg?label=tag&colorB=11ccbb)](https://github.com/holoviz/param/releases) [![PyPI version](https://img.shields.io/pypi/v/param.svg?colorB=cc77dd)](https://pypi.python.org/pypi/param) [![param version](https://img.shields.io/conda/v/pyviz/param.svg?colorB=4488ff&style=flat)](https://anaconda.org/pyviz/param) [![conda-forge version](https://img.shields.io/conda/v/conda-forge/param.svg?label=conda%7Cconda-forge&colorB=4488ff)](https://anaconda.org/conda-forge/param) [![defaults version](https://img.shields.io/conda/v/anaconda/param.svg?label=conda%7Cdefaults&style=flat&colorB=4488ff)](https://anaconda.org/anaconda/param) |

{param-2.0.2rc1 → param-2.1.0a2}/param/__init__.py

@@ -3,8 +3,8 @@ import os
 from . import version  # noqa: api import
 from .depends import depends  # noqa: api import
 from .parameterized import (  # noqa: api import
-    Parameterized, Parameter, String, ParameterizedFunction, ParamOverrides,
-    Undefined, get_logger
+    Parameterized, Parameter, Skip, String, ParameterizedFunction,
+    ParamOverrides, Undefined, get_logger
 )
 from .parameterized import (batch_watch, output, script_repr, # noqa: api import
                             discard_events, edit_constant)
@@ -161,6 +161,7 @@ __all__ = (
     'Selector',
     'SelectorBase',
     'Series',
+    'Skip',
     'String',
     'Time',
     'Tuple',

{param-2.0.2rc1 → param-2.1.0a2}/param/_utils.py

@@ -1,4 +1,6 @@
+import asyncio
 import collections
+import contextvars
 import datetime as dt
 import inspect
 import functools
@@ -21,6 +23,8 @@ DEFAULT_SIGNATURE = inspect.Signature([
     inspect.Parameter('params', inspect.Parameter.VAR_KEYWORD),
 ])
 
+MUTABLE_TYPES = (abc.MutableSequence, abc.MutableSet, abc.MutableMapping)
+
 class ParamWarning(Warning):
     """Base Param Warning"""
 
@@ -46,6 +50,10 @@ class ParamFutureWarning(ParamWarning, FutureWarning):
     Always displayed.
     """
 
+class Skip(Exception):
+    """
+    Exception that allows skipping an update when resolving a reference.
+    """
 
 def _deprecated(extra_msg="", warning_cat=ParamDeprecationWarning):
     def decorator(func):
@@ -184,7 +192,7 @@ def _validate_error_prefix(parameter, attribute=None):
 
 def _is_mutable_container(value):
     """True for mutable containers, which typically need special handling when being copied"""
-    return issubclass(type(value), (abc.MutableSequence, abc.MutableSet, abc.MutableMapping))
+    return issubclass(type(value), MUTABLE_TYPES)
 
 
 def _dict_update(dictionary, **kwargs):
@@ -219,6 +227,34 @@ def iscoroutinefunction(function):
         inspect.iscoroutinefunction(function)
     )
 
+async def _to_thread(func, /, *args, **kwargs):
+    """
+    Polyfill for asyncio.to_thread in Python < 3.9
+    """
+    loop = asyncio.get_running_loop()
+    ctx = contextvars.copy_context()
+    func_call = functools.partial(ctx.run, func, *args, **kwargs)
+    return await loop.run_in_executor(None, func_call)
+
+async def _to_async_gen(sync_gen):
+    done = object()
+
+    def safe_next():
+        # Converts StopIteration to a sentinel value to avoid:
+        # TypeError: StopIteration interacts badly with generators and cannot be raised into a Future
+        try:
+            return next(sync_gen)
+        except StopIteration:
+            return done
+
+    while True:
+        if sys.version_info >= (3, 9):
+            value = await asyncio.to_thread(safe_next)
+        else:
+            value = await _to_thread(safe_next)
+        if value is done:
+            break
+        yield value
 
 def flatten(line):
     """
@@ -552,3 +588,17 @@ def _in_ipython():
         return True
     except NameError:
         return False
+
+_running_tasks = set()
+
+def async_executor(func):
+    try:
+        event_loop = asyncio.get_running_loop()
+    except RuntimeError:
+        event_loop = asyncio.new_event_loop()
+    if event_loop.is_running():
+        task = asyncio.ensure_future(func())
+        _running_tasks.add(task)
+        task.add_done_callback(_running_tasks.discard)
+    else:
+        event_loop.run_until_complete(func())

{param-2.0.2rc1 → param-2.1.0a2}/param/_version.py

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

{param-2.0.2rc1 → param-2.1.0a2}/param/depends.py

@@ -1,3 +1,5 @@
+import inspect
+
 from collections import defaultdict
 from functools import wraps
 
@@ -31,7 +33,17 @@ def depends(func, *dependencies, watch=False, on_init=False, **kw):
         {key: transform_reference(arg) for key, arg in kw.items()}
     )
 
-    if iscoroutinefunction(func):
+    if inspect.isgeneratorfunction(func):
+        @wraps(func)
+        def _depends(*args, **kw):
+            for val in func(*args, **kw):
+                yield val
+    elif inspect.isasyncgenfunction(func):
+        @wraps(func)
+        async def _depends(*args, **kw):
+            async for val in func(*args, **kw):
+                yield val
+    elif iscoroutinefunction(func):
         @wraps(func)
         async def _depends(*args, **kw):
             return await func(*args, **kw)
@@ -72,7 +84,19 @@ def depends(func, *dependencies, watch=False, on_init=False, **kw):
                              'parameters by name.')
 
     if not string_specs and watch: # string_specs case handled elsewhere (later), in Parameterized.__init__
-        if iscoroutinefunction(func):
+        if inspect.isgeneratorfunction(func):
+            def cb(*events):
+                args = (getattr(dep.owner, dep.name) for dep in dependencies)
+                dep_kwargs = {n: getattr(dep.owner, dep.name) for n, dep in kw.items()}
+                for val in func(*args, **dep_kwargs):
+                    yield val
+        elif inspect.isasyncgenfunction(func):
+            async def cb(*events):
+                args = (getattr(dep.owner, dep.name) for dep in dependencies)
+                dep_kwargs = {n: getattr(dep.owner, dep.name) for n, dep in kw.items()}
+                async for val in func(*args, **dep_kwargs):
+                    yield val
+        elif iscoroutinefunction(func):
             async def cb(*events):
                 args = (getattr(dep.owner, dep.name) for dep in dependencies)
                 dep_kwargs = {n: getattr(dep.owner, dep.name) for n, dep in kw.items()}

{param-2.0.2rc1 → param-2.1.0a2}/param/ipython.py

@@ -25,7 +25,7 @@ import uuid
 import param
 
 from param.display import register_display_accessor
-
+from param._utils import async_executor
 
 # Whether to generate warnings when misformatted docstrings are found
 WARN_MISFORMATTED_DOCSTRINGS = False
@@ -364,23 +364,46 @@ class IPythonDisplay:
 
     def __call__(self):
         from param.depends import depends
-        from param.parameterized import resolve_ref
+        from param.parameterized import Undefined, resolve_ref
         from param.reactive import rx
 
+        handle = None
         if isinstance(self._reactive, rx):
             cb = self._reactive._callback
             @depends(*self._reactive._params, watch=True)
             def update_handle(*args, **kwargs):
-                handle.update(cb())
+                if handle is not None:
+                    handle.update(cb())
         else:
             cb = self._reactive
             @depends(*resolve_ref(cb), watch=True)
             def update_handle(*args, **kwargs):
-                handle.update(cb())
+                if handle is not None:
+                    handle.update(cb())
         try:
-            handle = display(cb(), display_id=uuid.uuid4().hex) # noqa
+            obj = cb()
+            if obj is Undefined:
+                obj = None
+            handle = display(obj, display_id=uuid.uuid4().hex) # noqa
         except TypeError:
             raise NotImplementedError
 
+def ipython_async_executor(func):
+    event_loop = None
+    try:
+        ip = get_ipython()  # noqa
+        if ip.kernel:
+            # We are in Jupyter and can piggyback the tornado IOLoop
+            from tornado.ioloop import IOLoop
+            ioloop = IOLoop.current()
+            event_loop = ioloop.asyncio_loop # type: ignore
+            if event_loop.is_running():
+                ioloop.add_callback(func)
+            else:
+                event_loop.run_until_complete(func())
+            return
+    except (NameError, AttributeError):
+        pass
+    async_executor(func)
 
 register_display_accessor('_ipython_display_', IPythonDisplay)

{param-2.0.2rc1 → param-2.1.0a2}/param/parameterized.py

@@ -42,6 +42,7 @@ from ._utils import (
     DEFAULT_SIGNATURE,
     ParamDeprecationWarning as _ParamDeprecationWarning,
     ParamFutureWarning as _ParamFutureWarning,
+    Skip,
     _deprecated,
     _deprecate_positional_args,
     _dict_update,
@@ -49,6 +50,7 @@ from ._utils import (
     _is_auto_name,
     _is_mutable_container,
     _recursive_repr,
+    _to_async_gen,
     _validate_error_prefix,
     accept_arguments,
     iscoroutinefunction,
@@ -61,11 +63,12 @@ from ._utils import (
 if _in_ipython():
     # In case the optional ipython module is unavailable
     try:
-        from .ipython import ParamPager
+        from .ipython import ParamPager, ipython_async_executor as async_executor
         param_pager = ParamPager(metaclass=True)  # Generates param description
     except ImportError:
-        param_pager = None
+        from ._utils import async_executor
 else:
+    from ._utils import async_executor
     param_pager = None
 
 
@@ -176,8 +179,11 @@ def resolve_value(value):
             resolve_value(value.step)
         )
     value = transform_reference(value)
-    if hasattr(value, '_dinfo') or iscoroutinefunction(value):
+    is_gen = inspect.isgeneratorfunction(value)
+    if hasattr(value, '_dinfo') or iscoroutinefunction(value) or is_gen:
         value = eval_function_with_deps(value)
+        if is_gen:
+            value = _to_async_gen(value)
     elif isinstance(value, Parameter):
         value = getattr(value.owner, value.name)
     return value
@@ -356,11 +362,6 @@ def discard_events(parameterized):
         parameterized.param._events = events
 
 
-# External components can register an async executor which will run
-# async functions
-async_executor = None
-
-
 def classlist(class_):
     """
     Return a list of the class hierarchy above (and including) the given class.
@@ -1469,12 +1470,16 @@ class Parameter(_ParameterBase):
         """
         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:
-            ref, deps, val, _ = obj.param._resolve_ref(self, val)
+            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:
                 del refs[name]
+                if name in obj._param__private.async_refs:
+                    obj._param__private.async_refs.pop(name).cancel()
+            if is_async or val is Undefined:
+                return
 
         # Deprecated Number set_hook called here to avoid duplicating setter
         if hasattr(self, 'set_hook'):
@@ -1752,16 +1757,17 @@ class _ParametersRestorer:
     Context-manager to handle the reset of parameter values after an update.
     """
 
-    def __init__(self, *, parameters, restore):
+    def __init__(self, *, parameters, restore, refs=None):
         self._parameters = parameters
         self._restore = restore
+        self._refs = {} if refs is None else refs
 
     def __enter__(self):
         return self._restore
 
     def __exit__(self, exc_type, exc_value, exc_tb):
         try:
-            self._parameters._update(self._restore)
+            self._parameters._update(dict(self._restore, **self._refs))
         finally:
             self._restore = {}
 
@@ -1963,7 +1969,7 @@ class Parameters:
             if ref is not None:
                 refs[name] = ref
                 deps[name] = ref_deps
-            if not is_async:
+            if not is_async and not (resolved is Undefined or resolved is Skip):
                 setattr(self, name, resolved)
         return refs, deps
 
@@ -1985,7 +1991,10 @@ class Parameters:
             ))
 
     def _update_ref(self_, name, ref):
-        for _, watcher in self_.self._param__private.ref_watchers:
+        param_private = self_.self._param__private
+        if name in param_private.async_refs:
+            param_private.async_refs.pop(name).cancel()
+        for _, watcher in param_private.ref_watchers:
             dep_obj = watcher.cls if watcher.inst is None else watcher.inst
             dep_obj.param.unwatch(watcher)
         self_.self._param__private.ref_watchers = []
@@ -1999,12 +2008,18 @@ class Parameters:
         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)
-            is_async = iscoroutinefunction(ref)
+            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
 
-            new_val = resolve_value(ref)
-            if is_async:
+            try:
+                new_val = resolve_value(ref)
+            except Skip:
+                new_val = Undefined
+            if new_val is Skip or new_val is Undefined:
+                continue
+            elif is_async:
                 async_executor(partial(self_._async_ref, pname, new_val))
                 continue
 
@@ -2015,12 +2030,16 @@ class Parameters:
                 self_.update(updates)
 
     def _resolve_ref(self_, pobj, value):
-        is_async = iscoroutinefunction(value)
+        is_gen = inspect.isgeneratorfunction(value)
+        is_async = iscoroutinefunction(value) or is_gen
         deps = resolve_ref(value, recursive=pobj.nested_refs)
-        if not deps and not is_async:
+        if not (deps or is_async or is_gen):
             return None, None, value, False
         ref = value
-        value = resolve_value(value)
+        try:
+            value = resolve_value(value)
+        except Skip:
+            value = Undefined
         if is_async:
             async_executor(partial(self_._async_ref, pobj.name, value))
             value = None
@@ -2030,9 +2049,13 @@ class Parameters:
         if not self_.self._param__private.initialized:
             async_executor(partial(self_._async_ref, pname, awaitable))
             return
-        if pname in self_.self._param__private.async_refs:
+
+        current_task = asyncio.current_task()
+        running_task = self_.self._param__private.async_refs.get(pname)
+        if running_task is None:
+            self_.self._param__private.async_refs[pname] = current_task
+        elif current_task is not running_task:
             self_.self._param__private.async_refs[pname].cancel()
-        self_.self._param__private.async_refs[pname] = asyncio.current_task()
         try:
             if isinstance(awaitable, types.AsyncGeneratorType):
                 async for new_obj in awaitable:
@@ -2040,11 +2063,14 @@ class Parameters:
                         self_.update({pname: new_obj})
             else:
                 with _syncing(self_.self, (pname,)):
-                    self_.update({pname: await awaitable})
-        except Exception as e:
-            raise e
+                    try:
+                        self_.update({pname: await awaitable})
+                    except Skip:
+                        pass
         finally:
-            del self_.self._param__private.async_refs[pname]
+            # Ensure we clean up but only if the task matches the currrent task
+            if self_.self._param__private.async_refs.get(pname) is current_task:
+                del self_.self._param__private.async_refs[pname]
 
     @classmethod
     def _changed(cls, event):
@@ -2266,7 +2292,7 @@ class Parameters:
 
     # Bothmethods
 
-    def update(self_, *args, **kwargs):
+    def update(self_, arg=Undefined, /, **kwargs):
         """
         For the given dictionary or iterable or set of param=value
         keyword arguments, sets the corresponding parameter of this
@@ -2275,22 +2301,26 @@ class Parameters:
         May also be used as a context manager to temporarily set and
         then reset parameter values.
         """
-        restore = self_._update(*args, **kwargs)
-        return _ParametersRestorer(parameters=self_, restore=restore)
-
-    def _update(self_, *args, **kwargs):
+        refs = {}
+        if self_.self is not None:
+            private = self_.self._param__private
+            params = list(kwargs if arg is Undefined else dict(arg, **kwargs))
+            for pname in params:
+                if pname in refs:
+                    continue
+                elif pname in private.refs:
+                    refs[pname] = private.refs[pname]
+                elif pname in private.async_refs:
+                    refs[pname] = private.async_refs[pname]
+        restore = dict(self_._update(arg, **kwargs))
+        return _ParametersRestorer(parameters=self_, restore=restore, refs=refs)
+
+    def _update(self_, arg=Undefined, /, **kwargs):
         BATCH_WATCH = self_._BATCH_WATCH
         self_._BATCH_WATCH = True
         self_or_cls = self_.self_or_cls
-        if args:
-            if len(args) == 1 and not kwargs:
-                kwargs = args[0]
-            else:
-                self_._BATCH_WATCH = False
-                raise ValueError(
-                    f"{self_.cls.__name__}.param.update accepts *either* an iterable "
-                    "or key=value pairs, not both."
-                )
+        if arg is not Undefined:
+            kwargs = dict(arg, **kwargs)
 
         trigger_params = [
             k for k in kwargs
@@ -2468,7 +2498,10 @@ class Parameters:
                                    watcher.fn)
             async_executor(partial(watcher.fn, *args, **kwargs))
         else:
-            watcher.fn(*args, **kwargs)
+            try:
+                watcher.fn(*args, **kwargs)
+            except Skip:
+                pass
 
     def _call_watcher(self_, watcher, event):
         """

{param-2.0.2rc1 → param-2.1.0a2}/param/parameters.py

@@ -16,15 +16,16 @@ parameter types (e.g. Number), and also imports the definition of
 Parameters and Parameterized classes.
 """
 
-import numbers
-import os.path
-import sys
+import collections
 import copy
-import glob
-import re
 import datetime as dt
-import collections
+import glob
+import inspect
+import numbers
+import os.path
 import pathlib
+import re
+import sys
 import typing
 import warnings
 
@@ -803,7 +804,7 @@ class Number(Dynamic):
                     )
 
     def _validate_value(self, val, allow_None):
-        if (allow_None and val is None) or callable(val):
+        if (allow_None and val is None) or (callable(val) and not inspect.isgeneratorfunction(val)):
             return
 
         if not _is_number(val):