When there are multiple actions in the queue, only call the "updated" methods for the last action

[adamghill]

This is a prototype to solve for #696. It changes the semantics of how the updated methods work, though -- instead of getting called for every action, when there are multiple actions in a queue (for example with deferred), the updated method would only get called once for the last action.

I do wonder:

1. If adding a new method (instead of using "updated") would be more appropriate, although I can't think of a good name for it.
2. Could I pass another argument along with the property value which indicates it's the last value in a queue? I can't think of a nice argument name for that either. Something like this arg name feels very messy, but would be "correct": def updated_search(self, search, is_last_or_only_action.
3. Another option would be add something to the component instance (aka self) which could be used, but this feel like it would expose a lot of internals that probably aren't all that useful to most people. But, theoretically I could add component_request to self, so then component code to do something with the last action would look something like this:

def updated_search(self, search):
    action_queue = self.component_request.action_queue

    if len(action_queue) > 1:
        last_action = action_queue[-1:][0]
            
        if last_action.payload.get("name") == "search" and last_action.payload.get("value") == search:
            print(f"this is the last one action: {search}")

That seems like a lot of boilerplate code for something that should be easier for users of the framework.

[cro]

Sorry for the lag in responding here. Number 1 above seems to be the cleanest API, avoiding many of the issues you list for the others (like exposing too many internals). In particular it makes it easy for devs to implement both "updated" semantics when they really want to handle every event, as well as just the last event.

After thinking a while I wonder if each_update and last_update would be good names?

[adamghill]

After thinking a while I wonder if each_update and last_update would be good names?

Makes sense. I think, to prevent changing the existing API, I would keep updated as-is, but add another method for the last update.

• last_updated_{field}
• final_updated_{field}
• finished_updated_{field}
• finished_{field}

Any of those sound ok? Or something else maybe?

[adamghill]

I was looking at synonyms for "completed" and ran across "resolved". I think that works and has the right connotation. So, my plan is to add a resolved_search(self, value) method that could be added to components which will only ever fire once with the last value for the field.

[cro]

This sounds logical!