Linked param ListSelector objects not updatting

Panel
1

This question is very similar to the GoogleMapViewer example and the related question on stackoverflow. I have been studying that example and would expect the code below to work, but it is not updating as I would expect.

There are a few differences between the example and my code:

  • I am using two ListSelector parameters rather than the ObjectSelector to obtain lists of items from the selection widgets rather than a single value.
  • I’m using a list parameter, selector_objects, that is updated by the method watching the join_mselect ListSelector parameter to update the selector ListSelector parameter rather than a static dictionary attribute.

The first version of the join_mselect_callback that is commented out and returns the selector_objects attribute behaves as expected by returning an updated list every time I make a selection of more than two items from the widget display of the join_mselect attribute.

The issue that I am having trouble resolving is that the second version of join_mselect_callback (with watch=True) does not cause the widget display of the selector to update automatically. I’ve noticed the following as I tried to determine why selector was not updating:

  • The selector_objects list does update as expected in the background.
  • If I set the objects of of selector, then the widget does update and it updates again if I make a selection from join_mselect. But, when I make a second selection from join_mselect it does not update. I’ve added a sequence of screenshots of this below the code section.
import panel as pn
import param
pn.extension()

lst = ['a', 'b', 'c']

class DynamicListSelector(param.Parameterized):
    selector_objects = param.List()
    join_mselect = param.ListSelector(default=[], objects=lst)
    selector = param.ListSelector(default=[], objects=lst)
    
    def __init__(self, **param):
        super().__init__(**param)
        self.selector_objects = lst
    
    # returns a modified list that updates as expected when selecting from join_mselect
#     @param.depends('join_mselect')
#     def join_mselect_callback(self):
#         if len(self.join_mselect) > 1:
#             self.selector_objects.append(self.join_mselect)
#             return self.selector_objects

    # selector_objects updates, but the selector widget does not update
    @param.depends('join_mselect', watch=True)
    def join_mselect_callback(self):
        if len(self.join_mselect) > 1:
            self.selector_objects.append(self.join_mselect)
            self.param['selector'].objects = self.selector_objects

example = DynamicListSelector()
# used with first version of join_mselect_callback where watch=False
# pn.Row(example.join_mselect_callback, example.param.join_mselect)

# use with second version of join_mselsect_callback where watch=True
pn.Row(example.param.selector, example.param.join_mselect)

Sequential screenshots of the unexpected behavior:
Selection of ‘a’ and ‘b’ caused the list attribute to update, but the widget does note update.

Screen Shot 2020-01-01 at 12.27.39 PM
Screen Shot 2020-01-01 at 12.27.39 PM759×188 9.16 KB

Setting the objects of the selector causes the widget to update.

Screen Shot 2020-01-01 at 12.28.16 PM
Screen Shot 2020-01-01 at 12.28.16 PM737×227 13.8 KB

Now, selecting from join mselect does cause the selector to update:

Screen Shot 2020-01-01 at 12.29.34 PM
Screen Shot 2020-01-01 at 12.29.34 PM728×231 16.9 KB

Selecting from join mselect a second time does not cause the selector to update, but like the initial step the list attribute does update.

Screen Shot 2020-01-01 at 12.30.56 PM
Screen Shot 2020-01-01 at 12.30.56 PM724×223 15 KB

2

After enough fiddling with this, I was able to create a version that behaves as I wanted.

I changed the callback function that updates the options of the selector parameter to use a variable within the function that is a copy of the selector_objects list rather than setting the objects of the selector parameter to the selector_objects parameter.

I think this resolved the issue because panel was not registering a change when the selector_objects list was appended to, but does register a change when the objects of selector (sorry that naming is confusing) is set to an actual new python list object in memory.

import panel as pn
import param

pn.extension()

lst = ['a', 'b', 'c']

class DynamicListSelector(param.Parameterized):
    selector_objects = param.List()
    join_mselect = param.ListSelector(default=[], objects=lst)
    selector = param.ListSelector(default=[], objects=lst)
    
    def __init__(self, **param):
        super().__init__(**param)
        self.selector_objects = lst

    @param.depends('join_mselect', watch=True)
    def join_mselect_callback(self):
        if len(self.join_mselect) > 1:
            temp_list = self.selector_objects.copy()
            temp_list.append(self.join_mselect)
            self.param['selector'].objects = temp_list
            self.selector_objects = temp_list

example = DynamicListSelector()
pn.Row(example.param.selector, example.param.join_mselect)
1 Like