Updates to new param API (#3735)

holoviews/core/data/__init__.py

@@ -98,7 +98,7 @@ def __call__(self, new_type, kdims=None, vdims=None, groupby=None,
         can be automatically sorted via the sort option and kwargs can
         be passed through.
         """
-        element_params = new_type.params()
+        element_params = new_type.param.objects()
         kdim_param = element_params['kdims']
         vdim_param = element_params['vdims']
         if isinstance(kdim_param.bounds[1], int):
@@ -119,7 +119,7 @@ def __call__(self, new_type, kdims=None, vdims=None, groupby=None,
         # Checks Element type supports dimensionality
         type_name = new_type.__name__
         for dim_type, dims in (('kdims', kdims), ('vdims', vdims)):
-            min_d, max_d = new_type.params(dim_type).bounds
+            min_d, max_d = element_params[dim_type].bounds
             if ((min_d is not None and len(dims) < min_d) or
                 (max_d is not None and len(dims) > max_d)):
                 raise ValueError("%s %s must be between length %s and %s." %
@@ -149,7 +149,7 @@ def __call__(self, new_type, kdims=None, vdims=None, groupby=None,
         params = {'kdims': [selected.get_dimension(kd, strict=True) for kd in kdims],
                   'vdims': [selected.get_dimension(vd, strict=True) for vd in vdims],
                   'label': selected.label}
-        if selected.group != selected.params()['group'].default:
+        if selected.group != selected.param.objects('existing')['group'].default:
             params['group'] = selected.group
         params.update(kwargs)
         if len(kdims) == selected.ndims or not groupby:
@@ -657,7 +657,7 @@ def aggregate(self, dimensions=None, function=None, spreadfn=None, **kwargs):
         vdims = [vd for vd in vdims if vd not in dropped]
 
         ndims = len(dimensions)
-        min_d, max_d = self.params('kdims').bounds
+        min_d, max_d = self.param.objects('existing')['kdims'].bounds
         generic_type = (min_d is not None and ndims < min_d) or (max_d is not None and ndims > max_d)
 
         if spreadfn:
@@ -679,7 +679,7 @@ def aggregate(self, dimensions=None, function=None, spreadfn=None, **kwargs):
                 # Should be checking the dimensions declared on the element are compatible
                 return self.clone(aggregated, kdims=kdims, vdims=vdims)
             except:
-                datatype = self.params('datatype').default
+                datatype = self.param.objects('existing')['datatype'].default
                 return self.clone(aggregated, kdims=kdims, vdims=vdims,
                                   new_type=Dataset if generic_type else None,
                                   datatype=datatype)

holoviews/core/data/pandas.py

@@ -30,7 +30,7 @@ def dimension_type(cls, dataset, dim):
 
     @classmethod
     def init(cls, eltype, data, kdims, vdims):
-        element_params = eltype.params()
+        element_params = eltype.param.objects()
         kdim_param = element_params['kdims']
         vdim_param = element_params['vdims']
         if util.is_series(data):

holoviews/core/data/xarray.py

@@ -61,7 +61,7 @@ def shape(cls, dataset, gridded=False):
     @classmethod
     def init(cls, eltype, data, kdims, vdims):
         import xarray as xr
-        element_params = eltype.params()
+        element_params = eltype.param.objects()
         kdim_param = element_params['kdims']
         vdim_param = element_params['vdims']
 

holoviews/core/dimension.py

@@ -387,10 +387,11 @@ def pprint(self):
         if len(set([changed.get(k, k) for k in ['name','label']])) == 1:
             return 'Dimension({spec})'.format(spec=repr(self.name))
 
-        ordering = sorted( sorted(changed.keys()),
-                           key=lambda k: (- float('inf')
-                                          if self.params(k).precedence is None
-                                          else self.params(k).precedence))
+        params = self.param.objects('existing')
+        ordering = sorted(
+            sorted(changed.keys()), key=lambda k: (
+                -float('inf') if params[k].precedence is None
+                else params[k].precedence))
         kws = ", ".join('%s=%r' % (k, changed[k]) for k in ordering if k != 'name')
         return 'Dimension({spec}, {kws})'.format(spec=repr(self.name), kws=kws)
 
@@ -547,10 +548,10 @@ def clone(self, data=None, shared_data=True, new_type=None, link=True,
             clone_type = self.__class__
         else:
             clone_type = new_type
-            new_params = new_type.params()
+            new_params = new_type.param.objects('existing')
             params = {k: v for k, v in params.items()
                       if k in new_params}
-            if params.get('group') == self.params()['group'].default:
+            if params.get('group') == self.param.objects('existing')['group'].default:
                 params.pop('group')
         settings = dict(params, **overrides)
         if 'id' not in settings:
@@ -1326,7 +1327,7 @@ class ViewableTree(AttrTree, Dimensioned):
     def __init__(self, items=None, identifier=None, parent=None, **kwargs):
         if items and all(isinstance(item, Dimensioned) for item in items):
             items = self._process_items(items)
-        params = {p: kwargs.pop(p) for p in list(self.params().keys())+['id', 'plot_id'] if p in kwargs}
+        params = {p: kwargs.pop(p) for p in list(self.param)+['id', 'plot_id'] if p in kwargs}
 
         AttrTree.__init__(self, items, identifier, parent, **kwargs)
         Dimensioned.__init__(self, self.data, **params)

holoviews/core/ndmapping.py

@@ -837,7 +837,7 @@ def clone(self, data=None, shared_data=True, new_type=None, link=True,
             clone_type = self.__class__
         else:
             clone_type = new_type
-            new_params = new_type.params()
+            new_params = new_type.param.objects()
             settings = {k: v for k, v in settings.items()
                       if k in new_params}
         settings = dict(settings, **overrides)

holoviews/core/options.py

@@ -320,7 +320,7 @@ def __len__(self):
 
 
     def __repr__(self):
-        if self.key == self.param.params('key').default:
+        if self.key == self.param.objects(False)['key'].default:
             vrepr = ''
         elif self.key:
             vrepr = repr(self.key)
@@ -1065,7 +1065,7 @@ def apply(self, value, input_ranges, backend=None):
             if self.transfer_parameters:
                 plot_opts = Store.lookup_options(backend, value, 'plot').kwargs
                 kwargs.update({k: v for k, v in plot_opts.items()
-                               if k in self.operation.params()})
+                               if k in self.operation.param})
 
         transformed = self.operation(value, input_ranges=input_ranges, **kwargs)
         if self.transfer_options:
@@ -1313,7 +1313,10 @@ def register(cls, associations, backend, style_aliases={}):
                              for opt in style_aliases.get(key, [])]
             style_opts = sorted(set(opt for opt in (expanded_opts + plot.style_opts)
                                     if opt not in plot._disabled_opts))
-            plot_opts = [k for k in plot.params().keys() if k not in ['name']]
+
+            # Special handling for PlotSelector which just proxies parameters
+            params = list(plot.param) if hasattr(plot, 'param') else plot.params()
+            plot_opts = [k for k in params if k not in ['name']]
 
             with param.logging_level('CRITICAL'):
                 plot.style_opts = style_opts

holoviews/core/pprint.py

@@ -44,16 +44,17 @@ def __call__(self, obj, filter_fn=None):
 
         name = obj.__name__ if isinstance(obj,type) else obj.__class__.__name__
         class_proxy = type(name, (param.Parameterized,),
-                      {k:v for k,v in obj.params().items() if filter_fn(k,v)})
+                      {k:v for k,v in obj.param.objects('existing').items()
+                       if filter_fn(k,v)})
 
         if isinstance(obj,type):
             return class_proxy
         else:
             instance_params = obj.get_param_values()
             obj_proxy = class_proxy()
             filtered = {k:v for k,v in instance_params
-                        if (k in obj_proxy.params())
-                            and not obj_proxy.params(k).constant}
+                        if (k in obj_proxy.param)
+                            and not obj_proxy.param.objects('existing')[k].constant}
             obj_proxy.param.set_param(**filtered)
             return obj_proxy
 
@@ -94,7 +95,7 @@ def get_parameter_info(cls, obj, ansi=False,  show_values=True,
         if cls.ppager is None: return ''
         if pattern is not None:
             obj = ParamFilter(obj, ParamFilter.regexp_filter(pattern))
-            if len(obj.params()) <=1:
+            if len(obj.param) <= 1:
                 return None
         param_info = cls.ppager.get_param_info(obj)
         param_list = cls.ppager.param_docstrings(param_info)
@@ -150,7 +151,7 @@ def info(cls, obj, ansi=False, backend='matplotlib', visualization=True,
         if visualization is False or plot_class is None:
             if pattern is not None:
                 obj = ParamFilter(obj, ParamFilter.regexp_filter(pattern))
-                if len(obj.params()) <=1:
+                if len(obj.param) <= 1:
                     return ('No %r parameters found matching specified pattern %r'
                             % (name, pattern))
             info = param.ipython.ParamPager()(obj)

holoviews/core/util.py

@@ -472,7 +472,7 @@ def callable_name(callable_obj):
             and issubclass(callable_obj, param.ParameterizedFunction)):
             return callable_obj.__name__
         elif (isinstance(callable_obj, param.Parameterized)
-              and 'operation' in callable_obj.params()):
+              and 'operation' in callable_obj.param):
             return callable_obj.operation.__name__
         elif isinstance(callable_obj, partial):
             return str(callable_obj)
@@ -1445,7 +1445,7 @@ def is_series(data):
 def get_param_values(data):
     params = dict(kdims=data.kdims, vdims=data.vdims,
                   label=data.label)
-    if (data.group != data.params()['group'].default and not
+    if (data.group != data.param.objects(False)['group'].default and not
         isinstance(type(data).group, property)):
         params['group'] = data.group
     return params
@@ -1478,7 +1478,7 @@ def disable_constant(parameterized):
     Temporarily set parameters on Parameterized object to
     constant=False.
     """
-    params = parameterized.params().values()
+    params = parameterized.param.objects('existing').values()
     constants = [p.constant for p in params]
     for p in params:
         p.constant = False
@@ -1526,7 +1526,7 @@ def stream_name_mapping(stream, exclude_params=['name'], reverse=False):
     If reverse is True, the mapping is from the renamed strings to the
     original stream parameter names.
     """
-    filtered = [k for k in stream.params().keys() if k not in exclude_params]
+    filtered = [k for k in stream.param if k not in exclude_params]
     mapping = {k:stream._rename.get(k,k) for k in filtered}
     if reverse:
         return {v:k for k,v in mapping.items()}

holoviews/ipython/__init__.py

@@ -281,7 +281,7 @@ def tab_completion_docstring(self_or_cls):
         of resources.
         """
         elements = ['%s=Boolean' %k for k in list(Store.renderers.keys())]
-        for name, p in self_or_cls.params().items():
+        for name, p in self_or_cls.param.objects().items():
             param_type = p.__class__.__name__
             elements.append("%s=%s" % (name, param_type))
 

holoviews/ipython/archive.py

@@ -94,7 +94,8 @@ def __init__(self, **params):
         self._timestamp = None
         self._tags = {MIME_TYPES[k]:v for k,v in HTML_TAGS.items() if k in MIME_TYPES}
 
-        keywords = ['%s=%s' % (k, v.__class__.__name__) for k,v in self.params().items()]
+        keywords = ['%s=%s' % (k, v.__class__.__name__)
+                    for k, v in self.param.objects().items()]
         self.auto.__func__.__doc__ = 'auto(enabled=Boolean, %s)' % ', '.join(keywords)
 
 

holoviews/ipython/display_hooks.py

@@ -79,7 +79,8 @@ def single_frame_plot(obj):
 
     plot_cls = renderer.plotting_class(obj)
     plot = plot_cls(obj, **renderer.plot_options(obj, renderer.size))
-    fmt = renderer.params('fig').objects[0] if renderer.fig == 'auto' else renderer.fig
+    fmt = (renderer.param.objects('existing')['fig'].objects[0]
+           if renderer.fig == 'auto' else renderer.fig)
     return plot, renderer, fmt
 
 
@@ -299,7 +300,7 @@ def image_display(element, max_frames, fmt):
     plot = renderer.get_plot(element)
 
     # Current renderer does not support the image format
-    if fmt not in renderer.params('fig').objects:
+    if fmt not in renderer.param.objects('existing')['fig'].objects:
         return None
 
     data, info = renderer(plot, fmt=fmt)

holoviews/operation/datashader.py

@@ -359,7 +359,7 @@ def _aggregate_ndoverlay(self, element, agg_fn):
         if ytype == 'datetime':
             y_range = tuple((np.array(y_range)/1e3).astype('datetime64[us]'))
         agg_params = dict({k: v for k, v in dict(self.get_param_values(), **self.p).items()
-                           if k in aggregate.params()},
+                           if k in aggregate.param},
                           x_range=x_range, y_range=y_range)
         bbox = BoundingBox(points=[(x_range[0], y_range[0]), (x_range[1], y_range[1])])
 
@@ -849,7 +849,7 @@ class rasterize(AggregationOperation):
     def _process(self, element, key=None):
         for predicate, transform in self._transforms:
             op_params = dict({k: v for k, v in self.p.items()
-                              if k in transform.params()
+                              if k in transform.param
                               and not (v is None and k == 'aggregator')},
                              dynamic=False)
             op = transform.instance(**op_params)

holoviews/plotting/plot.py

@@ -121,6 +121,7 @@ class PlotSelector(object):
     """
 
     _disabled_opts = []
+
     def __init__(self, selector, plot_classes, allow_mismatch=False):
         """
         The selector function accepts a component instance and returns

holoviews/util/__init__.py

@@ -903,8 +903,7 @@ def _process(self, element, key=None, kwargs={}):
         if util.is_param_method(self.p.operation) and util.get_method_owner(self.p.operation) is element:
             return self.p.operation(**kwargs)
         elif isinstance(self.p.operation, Operation):
-            kwargs = {k: v for k, v in kwargs.items()
-                      if k in self.p.operation.params()}
+            kwargs = {k: v for k, v in kwargs.items() if k in self.p.operation.param}
             return self.p.operation.process_element(element, key, **kwargs)
         else:
             return self.p.operation(element, **kwargs)

holoviews/util/settings.py

@@ -110,7 +110,8 @@ def list_backends():
     for backend in Store.renderers:
         backends.append(backend)
         renderer = Store.renderers[backend]
-        modes = [mode for mode in renderer.params('mode').objects if mode  != 'default']
+        modes = [mode for mode in renderer.param.objects('existing')['mode'].objects
+                 if mode  != 'default']
         backends += ['%s:%s' % (backend, mode) for mode in modes]
     return backends