Compatibility with param 1.9.0

panel/interact.py

@@ -412,7 +412,7 @@ def square(num=2):
         # If kwargs are given, replace self by a new
         # _InteractFactory with the updated kwargs
         if kwargs:
-            params = interactive.params()
+            params = list(interactive.param)
             kw = dict(self.kwargs)
             kw.update({k: v for k, v in kwargs.items() if k not in params})
             opts = dict(self.opts, **{k: v for k, v in kwargs.items() if k in params})

panel/layout.py

@@ -114,7 +114,7 @@ def _get_model(self, doc, root=None, parent=None, comm=None):
         objects = self._get_objects(model, [], doc, root, comm)
         props = dict(self._init_properties(), objects=objects)
         model.update(**self._process_param_change(props))
-        params = [p for p in self.params() if p != 'name']
+        params = [p for p in self.param if p != 'name']
         self._models[root.ref['id']] = model
         self._link_params(model, params, doc, root, comm)
         self._link_props(model, self._linked_props, doc, root, comm)

panel/pane.py

@@ -138,7 +138,7 @@ def __init__(self, object, **params):
                              (type(self).__name__, type(object).__name__))
 
         super(PaneBase, self).__init__(object=object, **params)
-        kwargs = {k: v for k, v in params.items() if k in Layoutable.params()}
+        kwargs = {k: v for k, v in params.items() if k in Layoutable.param}
         self.layout = self.default_layout(self, **kwargs)
 
     def __getitem__(self, index):
@@ -259,7 +259,7 @@ class DivPaneBase(PaneBase):
     _rename = {'object': 'text'}
 
     def _get_properties(self):
-        return {p : getattr(self,p) for p in list(Layoutable.params()) + ['style']
+        return {p : getattr(self,p) for p in list(Layoutable.param) + ['style']
                 if getattr(self, p) is not None}
 
     def _get_model(self, doc, root=None, parent=None, comm=None):

panel/param.py

@@ -127,7 +127,7 @@ def __init__(self, object, **params):
         if 'name' not in params:
             params['name'] = object.name
         if 'parameters' not in params:
-            params['parameters'] = [p for p in object.params() if p != 'name']
+            params['parameters'] = [p for p in object.param if p != 'name']
         super(Param, self).__init__(object, **params)
 
         # Construct widgets
@@ -162,11 +162,11 @@ def __init__(self, object, **params):
     def __repr__(self, depth=0):
         cls = type(self).__name__
         obj_cls = type(self.object).__name__
-        params = [] if self.object is None else self.object.params()
+        params = [] if self.object is None else list(self.object.param)
         parameters = [k for k in params if k != 'name']
         params = []
         for p, v in sorted(self.get_param_values()):
-            if v is self.params(p).default: continue
+            if v is self.param[p].default: continue
             elif v is None: continue
             elif isinstance(v, basestring) and v == '': continue
             elif p == 'object' or (p == 'name' and v.startswith(obj_cls)): continue
@@ -250,7 +250,7 @@ def widget_type(cls, pobj):
 
     def widget(self, p_name):
         """Get widget for param_name"""
-        p_obj = self.object.params(p_name)
+        p_obj = self.object.param[p_name]
 
         if self.widgets is None or p_name not in self.widgets:
             widget_class = self.widget_type(p_obj)
@@ -280,7 +280,7 @@ def widget(self, p_name):
             if ('start' not in kw or 'end' not in kw) and not issubclass(widget_class, LiteralInput):
                 widget_class = LiteralInput
 
-        kwargs = {k: v for k, v in kw.items() if k in widget_class.params()}
+        kwargs = {k: v for k, v in kw.items() if k in widget_class.param}
         widget = widget_class(**kwargs)
         watchers = self._callbacks['instance']
         if isinstance(p_obj, param.Action):
@@ -305,7 +305,7 @@ def link(change, _updating=[]):
                     if change.new < 0 and widget in self._widget_box.objects:
                         self._widget_box.pop(widget)
                     elif change.new >= 0 and widget not in self._widget_box.objects:
-                        precedence = lambda k: self.object.params(k).precedence
+                        precedence = lambda k: self.object.param[k].precedence
                         widgets = []
                         for k, ws in self._widgets.items():
                             if precedence(k) is None or precedence(k) >= self.display_threshold:
@@ -352,7 +352,7 @@ def _cleanup(self, root=None, final=False):
 
     def _get_widgets(self):
         """Return name,widget boxes for all parameters (i.e., a property sheet)"""
-        params = [(p, pobj) for p, pobj in self.object.params().items()
+        params = [(p, pobj) for p, pobj in self.object.param.objects('existing').items()
                   if p in self.parameters or p == 'name']
         key_fn = lambda x: x[1].precedence if x[1].precedence is not None else self.default_precedence
         sorted_precedence = sorted(params, key=key_fn)
@@ -397,12 +397,12 @@ class ParamMethod(PaneBase):
 
     def __init__(self, object, **params):
         self._kwargs =  {p: params.pop(p) for p in list(params)
-                         if p not in self.params()}
+                         if p not in self.param}
         super(ParamMethod, self).__init__(object, **params)
         kwargs = dict(self.get_param_values(), **dict(self._kwargs, _temporary=True))
         del kwargs['object']
         self._pane = Pane(self.object(), **kwargs)
-        self._inner_layout = Row(self._pane, **{k: v for k, v in params.items() if k in Row.params()})
+        self._inner_layout = Row(self._pane, **{k: v for k, v in params.items() if k in Row.param})
 
     @classmethod
     def applies(cls, obj):

panel/pipeline.py

@@ -94,7 +94,7 @@ def _init_stage(self):
         if self._state:
             results = {}
             for name, (_, method, index) in self._state.param.outputs().items():
-                if name not in stage.params():
+                if name not in stage.param:
                     continue
                 if method not in results:
                     results[method] = method()
@@ -103,10 +103,10 @@ def _init_stage(self):
                     result = result[index]
                 kwargs[name] = result
             if self.inherit_params:
-                params = [k for k, v in self._state.params().items()
+                params = [k for k, v in self._state.param.objects('existing').items()
                           if v.precedence is None or v.precedence >= 0]
                 kwargs.update({k: v for k, v in self._state.param.get_param_values()
-                               if k in stage.params() and k != 'name' and k in params})
+                               if k in stage.param and k != 'name' and k in params})
 
         if isinstance(stage, param.Parameterized):
             stage.set_param(**kwargs)

panel/tests/test_param.py

@@ -130,7 +130,7 @@ class Test(param.Parameterized):
     assert slider.value == 3.3
 
     # Check changing param attribute updates widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.bounds = (0.1, 5.5)
     assert slider.start == 0.1
     assert slider.end == 5.5
@@ -168,7 +168,7 @@ class Test(param.Parameterized):
     assert checkbox.active == [0]
 
     # Check changing param attribute updates widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.constant = True
     assert checkbox.disabled == True
 
@@ -199,7 +199,7 @@ class Test(param.Parameterized):
     assert widget.value == (0.2, 0.4)
 
     # Check changing param attribute updates widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.bounds = (0.1, 0.6)
     assert widget.start == 0.1
     assert widget.end == 0.6
@@ -238,7 +238,7 @@ class Test(param.Parameterized):
     assert slider.value == 3
 
     # Check changing param attribute updates widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.bounds = (1, 6)
     assert slider.start == 1
     assert slider.end == 6
@@ -276,7 +276,7 @@ class Test(param.Parameterized):
     assert slider.value == '1'
 
     # Check changing param attribute updates widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.objects = ['c', 'd', '1']
     assert slider.options == ['c', 'd', '1']
 
@@ -312,7 +312,7 @@ class Test(param.Parameterized):
     assert slider.value == ['c', '1']
 
     # Check changing param attribute updates widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.objects = ['c', 'd', '1']
     assert slider.options == ['c', 'd', '1']
 
@@ -363,7 +363,7 @@ class Test(param.Parameterized):
     test_pane = Pane(test, _temporary=True)
 
     # Check changing precedence attribute hides and shows widget
-    a_param = test.params('a')
+    a_param = test.param['a']
     a_param.precedence = -1
     assert test_pane._widgets['a'][0] not in test_pane._widget_box.objects
 
@@ -408,7 +408,7 @@ class Test(param.Parameterized):
 
     o1 = Test(name='Subobject 1')
     o2 = Test(name='Subobject 2')
-    Test.params('a').objects = [o1, o2, 3]
+    Test.param['a'].objects = [o1, o2, 3]
     test = Test(a=o1, name='Nested')
     test_pane = Pane(test, _temporary=True)
     model = test_pane._get_model(document, comm=comm)

panel/util.py

@@ -9,6 +9,7 @@
 import numbers
 import hashlib
 import threading
+import textwrap
 
 from collections import defaultdict, MutableSequence, MutableMapping, OrderedDict
 from datetime import datetime
@@ -17,8 +18,9 @@
 import param
 import bokeh
 import bokeh.embed.notebook
+from bokeh.document import Document
 from bokeh.io.notebook import load_notebook as bk_load_notebook
-from bokeh.models import Model, LayoutDOM
+from bokeh.models import Model, LayoutDOM, Box
 from bokeh.protocol import Protocol
 from bokeh.resources import CDN, INLINE
 from bokeh.util.string import encode_utf8
@@ -141,7 +143,7 @@ def param_reprs(parameterized, skip=[]):
     cls = type(parameterized).__name__
     param_reprs = []
     for p, v in sorted(parameterized.get_param_values()):
-        if v is parameterized.params(p).default: continue
+        if v is parameterized.param[p].default: continue
         elif v is None: continue
         elif isinstance(v, basestring) and v == '': continue
         elif isinstance(v, list) and v == []: continue
@@ -350,3 +352,33 @@ def render_mimebundle(model, doc, comm):
     data = {EXEC_MIME: '', 'text/html': html, 'application/javascript': bokeh_js}
     metadata = {EXEC_MIME: {'id': target}}
     return data, metadata
+
+
+def bokeh_repr(obj, depth=0, ignored=['children', 'text', 'name', 'toolbar', 'renderers', 'below', 'center', 'left', 'right']):
+    from .viewable import Viewable
+    if isinstance(obj, Viewable):
+        obj = obj._get_root(Document())
+
+    r = ""
+    cls = type(obj).__name__
+    properties = sorted(obj.properties_with_values(False).items())
+    props = []
+    for k, v in properties:
+        if k in ignored:
+            continue
+        if isinstance(v, Model):
+            v = '%s()' % type(v).__name__
+        else:
+            v = repr(v)
+        if len(v) > 30:
+            v = v[:30] + '...'
+        props.append('%s=%s' % (k, v))
+    props = ', '.join(props)
+    if isinstance(obj, Box):
+        r += '{cls}(children=[\n'.format(cls=cls)
+        for obj in obj.children:
+            r += textwrap.indent(bokeh_repr(obj, depth=depth+1) + ',\n', '  ')
+        r += '], %s)' % props
+    else:
+        r += '{cls}({props})'.format(cls=cls,  props=props)
+    return r

panel/widgets.py

@@ -72,7 +72,7 @@ def _get_model(self, doc, root=None, parent=None, comm=None):
         model = self._widget_type(**self._process_param_change(self._init_properties()))
 
         # Link parameters and bokeh model
-        params = [p for p in self.params()]
+        params = [p for p in self.param]
         properties = list(self._process_param_change(dict(self.get_param_values())))
         self._models[root.ref['id']] = model
         self._link_params(model, params, doc, root, comm)

setup.py

@@ -73,7 +73,7 @@ def run(self):
 
 install_requires = [
     'bokeh >=1.1.0dev8',
-    'param >=1.8.2',
+    'param >=1.9.0a1',
     'pyviz_comms >=0.7.0',
     'markdown',
     'pyct >=0.4.4',