How to trigger param.depends only once when updating multiple parameters

Param
1

Hi

I have a parameterized class with multiple parameters and one function that depends on a lot of these.

Sometimes I would like update multiple of these due to a change of “theme”. The problem is I have a function when depends on each of these parameters. And I only want it to run once for efficiency reasons.

What is the best way to achieve that?

Can I deactive the watchers while updating and then manually run the function when done? How?

Example

In the example below the dependent function is the _inc function. I want to be able to update both param1 and param2.

The actions in “red” are not working for me as they _inc twice.
The action in “green” is working for me as it runs _inc once.

But is it best practice?

image
image472×653 15.5 KB

import param
import panel as pn

class MultiParamApp(param.Parameterized):
    count = param.Integer(0)
    param1 = param.Integer(0)
    param2= param.Integer(0)
    update = param.Action()
    update_once = param.Action()
    update_once_disable_watchers = param.Action()
    reset = param.Action()

    view = param.Parameter()

    def __init__(self, **params):
        super().__init__(**params)

        self._updating = False

        self.update = self._update
        self.update_once = self._update_once
        self.update_once_disable_watchers = self._update_once_disable_watchers
        self.reset = self._reset

        self.view = pn.Param(self,
            widgets = {
                "update": {"button_type": "danger"},
                "update_once": {"button_type": "danger"},
                "update_once_disable_watchers": {"button_type": "success"},
            }
        )


    @param.depends("param1", "param2", watch=True)
    def _inc(self):
        if not self._updating:
            self.count += 1

    def _update(self, _=None):
        self.param1 = self.param1 +1
        self.param2 = self.param2 +1

    def _update_once(self, _=None):
        self.param.set_param(param1= self.param1+1, param2= self.param2+1)

    def _update_once_disable_watchers(self, _=None):
        self._updating = True
        self._update_once()
        self._updating = False
        self._inc()

    def _reset(self, _=None):
        self.count = 0

MultiParamApp().view.servable()
2

This one should definitely be working and if it isn’t that’s a real param bug that should be reported.

3

The _update_once() indeed unexpectedly runs _inc() twice.
Any update on this? Is it a bug?

1 Like
4

Hi @mcav

Only news I know of is that there is an issue on Github https://github.com/holoviz/param/issues/415 and it has been confirmed as a bug.

5

Did this ever get resolved in a manner that is clean?
I would like to have a way to change some param values but not update the display of the params until some code completes, and at the end call a some member function to then cause the display to update,
but am having no luck!

Can this be made to work?
I’ll append one version of my test code here for reference:

import panel as pn
import param

class MinimalExample(pn.viewable.Viewer):
    counter  = param.Integer(default=0)
    _refresh = param.Boolean(default=False)

    def increment(self, event=None):
        """Modify state and trigger UI update."""
        self.counter += 1    # Change state
        self._update_view()  # Call update function

    def _update_view(self):
        """Forces UI refresh."""
        print(f"[DEBUG] Updating view, counter={self.counter}")
        if True: #with param.parameterized.discard_events(self):
            self._refresh = not self._refresh  # Forces UI update?

    @pn.depends("_refresh", watch=True)  # Auto-update UI when _refresh changes
    def view(self):
        """Defines the UI."""
        return pn.Column(
            self.counter,  # Displays updated state
            pn.widgets.Button(name="Increment", button_type="primary", on_click=self.increment)
        )

    def __panel__(self):
        """Returns the Panel layout."""
        return self.view()  # Calls `view()` for dynamic updates

# Instantiate and serve the minimal app
app = MinimalExample()
app.servable()
6

Maybe:
https://panel.holoviz.org/how_to/performance/hold.html