Add version guards for param watch functionality

holoviews/core/spaces.py

@@ -742,7 +742,8 @@ def __init__(self, callback, initial_items=None, streams=None, **params):
         streams = (streams or [])
 
         # If callback is a parameterized method and watch is disabled add as stream
-        if util.is_param_method(callback) and params.get('watch', True):
+        param_watch_support = util.param_version >= '1.8.0'
+        if util.is_param_method(callback) and params.get('watch', param_watch_support):
             streams.append(callback)
 
         if isinstance(callback, types.GeneratorType):
@@ -760,12 +761,12 @@ def __init__(self, callback, initial_items=None, streams=None, **params):
         parameterizeds = [s.parameterized for s in streams if isinstance(s, ParamStream)]
         for s in streams:
             if not isinstance(s, Stream):
-                if isinstance(s, param.Parameterized):
+                if isinstance(s, param.Parameterized) and param_watch_support:
                     if s not in parameterizeds:
                         s = ParamStream(s)
                     else:
                         continue
-                elif util.is_param_method(s):
+                elif util.is_param_method(s) and param_watch_support:
                     if not hasattr(s, "_dinfo") or util.get_method_owner(s) in parameterizeds:
                         continue
                     else:

holoviews/core/util.py

@@ -38,6 +38,7 @@
     get_keywords = operator.attrgetter('keywords')
 
 numpy_version = LooseVersion(np.__version__)
+param_version = LooseVersion(param.__version__)
 
 datetime_types = (np.datetime64, dt.datetime, dt.date)
 timedelta_types = (np.timedelta64, dt.timedelta,)

holoviews/streams.py

@@ -555,27 +555,33 @@ class ParamStream(Stream):
     object.
     """
 
-    parameterized = param.ClassSelector(class_=param.Parameterized, constant=True, doc="""
+    parameterized = param.ClassSelector(class_=(param.Parameterized,
+                                                param.parameterized.ParameterizedMetaclass),
+                                        constant=True, doc="""
         Parameterized instance to watch for parameter changes.""")
 
     parameters = param.List([], constant=True, doc="""
         Parameters on the parameterized to watch.""")
 
-    def __init__(self, parameterized, parameters=None, **params):
+    def __init__(self, parameterized, parameters=None, watch=True, **params):
+        if util.param_version < '1.8.0' and watch:
+            raise RuntimeError('ParamStream requires param version >= 1.8.0, '
+                               'to support watching parameters.')
         self.is_method = util.is_param_method(parameterized)
         if self.is_method:
             method = parameterized
             parameterized = util.get_method_owner(parameterized)
             parameters = [p.name for p in parameterized.param.params_depended_on(method.__name__)]
         elif parameters is None:
-            parameters = [p for p in parameterized.params()]
+            parameters = [p for p in parameterized.params() if p != 'name']
 
         super(ParamStream, self).__init__(
             parameterized=parameterized,
             parameters=parameters, **params
         )
-        for p in self.parameters:
-            self.parameterized.param.watch(self._listener, p)
+        if watch:
+            for p in self.parameters:
+                self.parameterized.param.watch(self._listener, p)
 
     def _listener(self, change):
         self.trigger([self])
@@ -594,7 +600,11 @@ def contents(self):
 
 
 # Backward compatibility
-ParamValues = ParamStream
+def ParamValues(*args, **kwargs):
+    param.main.warning('ParamValues stream is deprecated, use ParamStream instead.')
+    kwargs['watch'] = False
+    return ParamStream(*args, **kwargs)
+
 
 
 class LinkedStream(Stream):