Cleaned up init_params definitions (#1960)

* Cleaned up init_params definitions

* Fix flake

panel/layout/base.py

@@ -79,12 +79,6 @@ def _update_model(self, events, msg, root, model, doc, comm=None):
     # Model API
     #----------------------------------------------------------------
 
-    def _init_params(self):
-        properties = {k: v for k, v in self.param.get_param_values()
-                      if v is not None}
-        del properties['objects']
-        return self._process_param_change(properties)
-
     def _get_objects(self, model, old_objects, doc, root, comm=None):
         """
         Returns new child models for the layout while reusing unchanged

panel/layout/grid.py

@@ -30,10 +30,9 @@ class GridBox(ListPanel):
 
     _bokeh_model = BkGridBox
 
-    _rename = {'objects': 'children'}
+    _rename = {'objects': 'children', 'nrows': None, 'ncols': None}
 
-    _source_transforms = {'scroll': None, 'objects': None,
-                         'nrows': None, 'ncols': None}
+    _source_transforms = {'scroll': None, 'objects': None}
 
     @classmethod
     def _flatten_grid(cls, layout, nrows=None, ncols=None):
@@ -132,10 +131,9 @@ def _get_model(self, doc, root=None, parent=None, comm=None):
         if root is None:
             root = model
         objects = self._get_objects(model, [], doc, root, comm)
-        model.children = self._get_children(objects, self.nrows, self.ncols)
-        props = {k: v for k, v in self._init_params().items()
-                 if k not in ('nrows', 'ncols')}
-        model.update(**self._process_param_change(props))
+        properties = self._process_param_change(self._init_params())
+        properties['children'] = self._get_children(objects, self.nrows, self.ncols)
+        model.update(**properties)
         self._models[root.ref['id']] = (model, parent)
         self._link_props(model, self._linked_props, doc, root, comm)
         return model
@@ -223,13 +221,13 @@ def _update_grid_size(self):
         self._updating = False
 
     def _init_params(self):
-        properties = super()._init_params()
+        params = super()._init_params()
         if self.sizing_mode not in ['fixed', None]:
-            if 'min_width' not in properties and 'width' in properties:
-                properties['min_width'] = properties['width']
-            if 'min_height' not in properties and 'height' in properties:
-                properties['min_height'] = properties['height']
-        return properties
+            if 'min_width' not in params and 'width' in params:
+                params['min_width'] = params['width']
+            if 'min_height' not in params and 'height' in params:
+                params['min_height'] = params['height']
+        return params
 
     def _get_objects(self, model, old_objects, doc, root, comm=None):
         from ..pane.base import RerenderError

panel/layout/tabs.py

@@ -32,28 +32,25 @@ class Tabs(NamedListPanel):
 
     _bokeh_model = BkTabs
 
-    _source_transforms = {'dynamic': None, 'objects': None}
-
-    _rename = {'name': None, 'objects': 'tabs', 'dynamic': None}
-
-    _linked_props = ['active', 'tabs']
-
     _js_transforms = {'tabs': """
     var ids = [];
     for (var t of value) {{ ids.push(t.id) }};
     var value = ids;
     """}
 
+    _linked_props = ['active', 'tabs']
+
+    _manual_params = ['closable']
+
+    _rename = {'name': None, 'objects': 'tabs', 'dynamic': None}
+
+    _source_transforms = {'dynamic': None, 'objects': None}
+
     def __init__(self, *objects, **params):
         super().__init__(*objects, **params)
         self.param.active.bounds = (0, len(self)-1)
         self.param.watch(self._update_active, ['dynamic', 'active'])
 
-    def _init_params(self):
-        return {k: v for k, v in self.param.get_param_values()
-                if v is not None and k != 'closable'}
-
-
     def _update_names(self, event):
         self.param.active.bounds = (0, len(event.new)-1)
         super()._update_names(event)
@@ -111,13 +108,11 @@ def _update_active(self, *events):
     # Model API
     #----------------------------------------------------------------
 
-    def _update_model(self, events, msg, root, model, doc, comm=None):
-        msg = dict(msg)
-        if 'closable' in msg:
-            closable = msg.pop('closable')
-            for child in model.tabs:
-                child.closable = closable
-        super()._update_model(events, msg, root, model, doc, comm)
+    def _manual_update(self, events, model, doc, root, parent, comm):
+        for event in events:
+            if event.name == 'closable':
+                for child in model.tabs:
+                    child.closable = event.new
 
     def _get_objects(self, model, old_objects, doc, root, comm=None):
         """

panel/pane/base.py

@@ -139,13 +139,9 @@ def _linkable_params(self):
 
     @property
     def _synced_params(self):
-        ignored_params = ['name', 'default_layout']+self._rerender_params
+        ignored_params = ['name', 'default_layout', 'loading']+self._rerender_params
         return [p for p in self.param if p not in ignored_params]
 
-    def _init_params(self):
-        return {k: v for k, v in self.param.get_param_values()
-                if v is not None and k not in ['default_layout', 'object']}
-
     def _update_object(self, ref, doc, root, parent, comm):
         old_model = self._models[ref][0]
         if self._updates:

panel/pane/media.py

@@ -58,10 +58,6 @@ def applies(cls, obj):
             return True
         return False
 
-    def _init_params(self):
-        return {k: v for k, v in self.param.get_param_values()
-                if v is not None and k not in ['default_layout']}
-
     def _get_model(self, doc, root=None, parent=None, comm=None):
         props = self._process_param_change(self._init_params())
         model = self._bokeh_model(**props)

panel/pane/vtk/vtk.py

@@ -629,12 +629,6 @@ def _update_object(self, ref, doc, root, parent, comm):
         self._legend = None
         super()._update_object(ref, doc, root, parent, comm)
 
-    def _init_params(self):
-        return {k: v for k, v in self.param.get_param_values()
-                if v is not None and k not in [
-                    'default_layout', 'object', 'max_data_size', 'spacing', 'origin'
-                ]}
-
     def _get_object_dimensions(self):
         if isinstance(self.object, np.ndarray):
             return self.object.shape

panel/param.py

@@ -214,7 +214,7 @@ def __repr__(self, depth=0):
 
     @property
     def _synced_params(self):
-        ignored_params = ['default_layout']
+        ignored_params = ['default_layout', 'loading']
         return [p for p in Layoutable.param if p not in ignored_params]
 
     def _update_widgets(self, *events):

panel/reactive.py

@@ -137,7 +137,12 @@ def _synced_params(self):
         Parameters which are synced with properties using transforms
         applied in the _process_param_change method.
         """
-        return [p for p in self.param if p not in self._manual_params]
+        ignored = ['default_layout', 'loading']
+        return [p for p in self.param if p not in self._manual_params+ignored]
+
+    def _init_params(self):
+        return {k: v for k, v in self.param.get_param_values()
+                if k in self._synced_params and v is not None}
 
     def _link_params(self):
         params = self._synced_params

panel/viewable.py

@@ -435,12 +435,7 @@ def _render_model(self, doc=None, comm=None):
         return model
 
     def _init_params(self):
-        params = {}
-        for k, v in self.param.get_param_values():
-            if v is None:
-                continue
-            params[k] = v
-        return params
+        return {k: v for k, v in self.param.get_param_values() if v is not None}
 
     def _server_destroy(self, session_context):
         """

panel/widgets/base.py

@@ -72,7 +72,6 @@ def from_param(cls, parameter, **params):
         layout = Param(parameter, widgets={parameter.name: dict(type=cls, **params)})
         return layout[0]
 
-
     def _get_model(self, doc, root=None, parent=None, comm=None):
         model = self._widget_type(**self._process_param_change(self._init_params()))
         if root is None:

panel/widgets/indicators.py

@@ -400,10 +400,6 @@ def __init__(self, **params):
     def _update_value_bounds(self):
         self.param.value.bounds = self.bounds
 
-    def _init_params(self):
-        return {k: v for k, v in self.param.get_param_values()
-                if v is not None and k not in self._manual_params}
-
     def _get_data(self):
         vmin, vmax = self.bounds
         value = self.value