Refactor callbacks to be initialized on instantiation

panel/interact.py

@@ -146,8 +146,7 @@ def __init__(self, object, params={}, **kwargs):
         if self.manual_update:
             widgets.append(('manual', Button(name=self.manual_name)))
         self._widgets = OrderedDict(widgets)
-        self._pane = Pane(self.object(**self.kwargs), name=self.name,
-                          _temporary=True)
+        self._pane = Pane(self.object(**self.kwargs), name=self.name)
         self._inner_layout = Row(self._pane)
         widgets = [widget for _, widget in widgets if isinstance(widget, Widget)]
         if 'name' in params:
@@ -156,35 +155,20 @@ def __init__(self, object, params={}, **kwargs):
         self.layout.objects = [self.widget_box, self._inner_layout]
         self._link_widgets()
 
-    @property
-    def kwargs(self):
-        return {k: widget.value for k, widget in self._widgets.items()
-                if k != 'manual'}
-
-    def signature(self):
-        return signature(self.object)
-
-    def find_abbreviations(self, kwargs):
-        """Find the abbreviations for the given function and kwargs.
-        Return (name, abbrev, default) tuples.
-        """
-        new_kwargs = []
-        try:
-            sig = self.signature()
-        except (ValueError, TypeError):
-            # can't inspect, no info from function; only use kwargs
-            return [ (key, value, value) for key, value in kwargs.items() ]
-
-        for parameter in sig.parameters.values():
-            for name, value, default in _yield_abbreviations_for_parameter(parameter, kwargs):
-                if value is empty:
-                    raise ValueError('cannot find widget or abbreviation for argument: {!r}'.format(name))
-                new_kwargs.append((name, value, default))
-        return new_kwargs
+    #----------------------------------------------------------------
+    # Model API
+    #----------------------------------------------------------------
 
     def _get_model(self, doc, root=None, parent=None, comm=None):
         return self._inner_layout._get_model(doc, root, parent, comm)
 
+    #----------------------------------------------------------------
+    # Callback API
+    #----------------------------------------------------------------
+
+    def _synced_params(self):
+        return []
+
     def _link_widgets(self):
         if self.manual_update:
             widgets = [('manual', self._widgets['manual'])]
@@ -200,27 +184,52 @@ def update_pane(change):
                     if isinstance(new_object, (PaneBase, Panel)):
                         new_params = {k: v for k, v in new_object.get_param_values()
                                       if k != 'name'}
-                        try:
-                            self._pane.set_param(**new_params)
-                        except:
-                            raise
-                        finally:
-                            new_object._cleanup(final=new_object._temporary)
+                        self._pane.set_param(**new_params)
                     else:
                         self._pane.object = new_object
                     return
 
                 # Replace pane entirely
-                self._pane = Pane(new_object, _temporary=True)
+                self._pane = Pane(new_object)
                 self._inner_layout[0] = self._pane
 
             pname = 'clicks' if name == 'manual' else 'value'
             watcher = widget.param.watch(update_pane, pname)
-            self._callbacks['instance'].append(watcher)
+            self._callbacks.append(watcher)
 
-    def _cleanup(self, root=None, final=False):
-        self._inner_layout._cleanup(root, final)
-        super(interactive, self)._cleanup(root, final)
+    def _cleanup(self, root):
+        self._inner_layout._cleanup(root)
+        super(interactive, self)._cleanup(root)
+
+    #----------------------------------------------------------------
+    # Public API
+    #----------------------------------------------------------------
+
+    @property
+    def kwargs(self):
+        return {k: widget.value for k, widget in self._widgets.items()
+                if k != 'manual'}
+
+    def signature(self):
+        return signature(self.object)
+
+    def find_abbreviations(self, kwargs):
+        """Find the abbreviations for the given function and kwargs.
+        Return (name, abbrev, default) tuples.
+        """
+        new_kwargs = []
+        try:
+            sig = self.signature()
+        except (ValueError, TypeError):
+            # can't inspect, no info from function; only use kwargs
+            return [ (key, value, value) for key, value in kwargs.items() ]
+
+        for parameter in sig.parameters.values():
+            for name, value, default in _yield_abbreviations_for_parameter(parameter, kwargs):
+                if value is empty:
+                    raise ValueError('cannot find widget or abbreviation for argument: {!r}'.format(name))
+                new_kwargs.append((name, value, default))
+        return new_kwargs
 
     def widgets_from_abbreviations(self, seq):
         """Given a sequence of (name, abbrev, default) tuples, return a sequence of Widgets."""

panel/io.py

@@ -82,7 +82,7 @@ def _cleanup_panel(msg_id):
     """
     if msg_id not in state._views:
         return
-    viewable, model = state._views.pop(msg_id)
+    viewable, model, _, _ = state._views.pop(msg_id)
     viewable._cleanup(model)
 
 

panel/layout.py

@@ -10,8 +10,7 @@
                           Spacer as BkSpacer)
 from bokeh.models.widgets import Tabs as BkTabs, Panel as BkPanel
 
-from .io import state
-from .util import param_name, param_reprs, push
+from .util import param_name, param_reprs
 from .viewable import Reactive
 
 
@@ -36,60 +35,42 @@ def __init__(self, *objects, **params):
         objects = [panel(pane) for pane in objects]
         super(Panel, self).__init__(objects=objects, **params)
 
-    def _link_params(self, model, params, doc, root, comm=None):
-        def set_value(*events):
-            msg = {event.name: event.new for event in events}
-            events = {event.name: event for event in events}
-
-            def update_model():
-                if 'objects' in msg:
-                    old = events['objects'].old
-                    msg['objects'] = self._get_objects(model, old, doc, root, comm)
-                    for pane in old:
-                        if pane not in self.objects:
-                            pane._cleanup(root)
-                    self._preprocess(root) #preprocess links between new elements
-                processed = self._process_param_change(msg)
-                model.update(**processed)
-
-            if comm:
-                update_model()
-                push(doc, comm)
-            elif state.curdoc:
-                update_model()
-            else:
-                doc.add_next_tick_callback(update_model)
-
-        ref = root.ref['id']
-        if ref not in self._callbacks:
-            watcher = self.param.watch(set_value, params)
-            self._callbacks[ref].append(watcher)
-
-    def _cleanup(self, root=None, final=False):
-        super(Panel, self)._cleanup(root, final)
-        if root is not None:
-            for p in self.objects:
-                p._cleanup(root, final)
-
-    def select(self, selector=None):
-        """
-        Iterates over the Viewable and any potential children in the
-        applying the Selector.
-
-        Arguments
-        ---------
-        selector: type or callable or None
-            The selector allows selecting a subset of Viewables by
-            declaring a type or callable function to filter by.
-
-        Returns
-        -------
-        viewables: list(Viewable)
-        """
-        objects = super(Panel, self).select(selector)
-        for obj in self.objects:
-            objects += obj.select(selector)
-        return objects
+    def __repr__(self, depth=0, max_depth=10):
+        if depth > max_depth:
+            return '...'
+        spacer = '\n' + ('    ' * (depth+1))
+        cls = type(self).__name__
+        params = param_reprs(self, ['objects'])
+        objs = ['[%d] %s' % (i, obj.__repr__(depth+1)) for i, obj in enumerate(self)]
+        if not params and not objs:
+            return super(Panel, self).__repr__(depth+1)
+        elif not params:
+            template = '{cls}{spacer}{objs}'
+        elif not objs:
+            template = '{cls}({params})'
+        else:
+            template = '{cls}({params}){spacer}{objs}'
+        return template.format(
+            cls=cls, params=', '.join(params),
+            objs=('%s' % spacer).join(objs), spacer=spacer)
+
+    #----------------------------------------------------------------
+    # Callback API
+    #----------------------------------------------------------------
+
+    def _update_model(self, events, msg, root, model, doc, comm=None):
+        if self._rename['objects'] in msg:
+            old = events['objects'].old
+            msg[self._rename['objects']] = self._get_objects(model, old, doc, root, comm)
+            for pane in old:
+                if pane not in self.objects:
+                    pane._cleanup(root)
+        model.update(**msg)
+        self._preprocess(root) #preprocess links between new elements
+
+    #----------------------------------------------------------------
+    # Model API
+    #----------------------------------------------------------------
 
     def _get_objects(self, model, old_objects, doc, root, comm=None):
         """
@@ -102,10 +83,13 @@ def _get_objects(self, model, old_objects, doc, root, comm=None):
             pane = panel(pane)
             self.objects[i] = pane
             if pane in old_objects:
-                child = pane._models[root.ref['id']]
+                child, _ = pane._models[root.ref['id']]
             else:
                 child = pane._get_model(doc, root, model, comm)
             new_models.append(child)
+        for obj in old_objects:
+            if obj not in self.objects:
+                obj._cleanup(root)
         return new_models
 
     def _get_model(self, doc, root=None, parent=None, comm=None):
@@ -115,12 +99,19 @@ 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.param if p != 'name']
-        self._models[root.ref['id']] = model
-        self._link_params(model, params, doc, root, comm)
+        self._models[root.ref['id']] = (model, parent)
         self._link_props(model, self._linked_props, doc, root, comm)
         return model
 
+    def _cleanup(self, root):
+        super(Panel, self)._cleanup(root)
+        for p in self.objects:
+            p._cleanup(root)
+
+    #----------------------------------------------------------------
+    # Public API
+    #----------------------------------------------------------------
+
     def __getitem__(self, index):
         return self.objects[index]
 
@@ -170,25 +161,25 @@ def __setitem__(self, index, panes):
             new_objects[i] = panel(pane)
         self.objects = new_objects
 
-    def __repr__(self, depth=0, max_depth=10):
-        if depth > max_depth:
-            return '...'
-        spacer = '\n' + ('    ' * (depth+1))
-        cls = type(self).__name__
-        params = param_reprs(self, ['objects'])
-        objs = ['[%d] %s' % (i, obj.__repr__(depth+1)) for i, obj in enumerate(self)]
-        if not params and not objs:
-            return super(Panel, self).__repr__(depth+1)
-        elif not params:
-            template = '{cls}{spacer}{objs}'
-        elif not objs:
-            template = '{cls}({params})'
-        else:
-            template = '{cls}({params}){spacer}{objs}'
-        return template.format(
-            cls=cls, params=', '.join(params),
-            objs=('%s' % spacer).join(objs), spacer=spacer
-        )
+    def select(self, selector=None):
+        """
+        Iterates over the Viewable and any potential children in the
+        applying the Selector.
+
+        Arguments
+        ---------
+        selector: type or callable or None
+            The selector allows selecting a subset of Viewables by
+            declaring a type or callable function to filter by.
+
+        Returns
+        -------
+        viewables: list(Viewable)
+        """
+        objects = super(Panel, self).select(selector)
+        for obj in self.objects:
+            objects += obj.select(selector)
+        return objects
 
     def append(self, pane):
         from .pane import panel
@@ -270,6 +261,9 @@ def __init__(self, *items, **params):
         objects, self._names = self._to_objects_and_names(items)
         super(Tabs, self).__init__(*objects, **params)
         self.param.watch(self._update_names, 'objects')
+        # ALERT: Ensure that name update happens first, should be
+        #        replaced by watch precedence support in param
+        self._param_watchers['objects']['value'].reverse()
 
     def _to_object_and_name(self, item):
         from .pane import panel
@@ -289,6 +283,10 @@ def _to_objects_and_names(self, items):
             names.append(name)
         return objects, names
 
+    #----------------------------------------------------------------
+    # Callback API
+    #----------------------------------------------------------------
+
     def _update_names(self, event):
         if len(event.new) == len(self._names):
             return
@@ -302,6 +300,10 @@ def _update_names(self, event):
             names.append(name)
         self._names = names
 
+    #----------------------------------------------------------------
+    # Model API
+    #----------------------------------------------------------------
+
     def _get_objects(self, model, old_objects, doc, root, comm=None):
         """
         Returns new child models for the layout while reusing unchanged
@@ -318,13 +320,20 @@ def _get_objects(self, model, old_objects, doc, root, comm=None):
             pane = panel(pane, name=name)
             self.objects[i] = pane
             if pane in old_objects:
-                child = pane._models[root.ref['id']]
+                child, _ = pane._models[root.ref['id']]
             else:
                 child = pane._get_model(doc, root, model, comm)
             child = BkPanel(title=name, name=pane.name, child=child)
             new_models.append(child)
+        for obj in old_objects:
+            if obj not in self.objects:
+                obj._cleanup(root)
         return new_models
 
+    #----------------------------------------------------------------
+    # Public API
+    #----------------------------------------------------------------
+
     def __setitem__(self, index, panes):
         new_objects = list(self)
         if not isinstance(index, slice):
@@ -415,11 +424,11 @@ class Spacer(Reactive):
     _bokeh_model = BkSpacer
 
     def _get_model(self, doc, root=None, parent=None, comm=None):
-        model = self._bokeh_model(**self._process_param_change(self._init_properties()))
+        properties = self._process_param_change(self._init_properties())
+        model = self._bokeh_model(**properties)
         if root is None:
             root = model
-        self._models[root.ref['id']] = model
-        self._link_params(model, ['width', 'height'], doc, root, comm)
+        self._models[root.ref['id']] = (model, parent)
         return model
 
 

panel/links.py

@@ -180,7 +180,7 @@ def _resolve_model(cls, root_model, obj, model_spec):
                     model_spec = None
                 model = obj.handles[handle_spec]
         elif isinstance(obj, Viewable):
-            model = obj._models[root_model.ref['id']]
+            model, _ = obj._models[root_model.ref['id']]
         elif isinstance(obj, BkModel):
             model = obj
         if model_spec is not None: