Idea: Debounce and throttle options for observing traits

[maartenbreddels]

Two use cases:

1. Using interact or a slider that causes something to execute which say takes ~100 ms to complete, you don't want events to be delivered all the time, but you may want to update it say every 250 ms, when a slider is changing value.
2. I'm using bqplot and listening to a change in the min value of one of the axes. Only when it didn't change for say 500msec, I expect the user to be done with zooming and panning and will start a heavy computation to rebuild the figure.

If this is done on the client side (js), this will also lead to less traffic/events.

I can imaging something like this

interact(f, x=10, throttle=250);

For the bqplot use case

scale_x.observe(f, "xmin", debounce=500)

See here for a visual explaination:
http://benalman.com/projects/jquery-throttle-debounce-plugin/

throttle and debounced functions are also available in underscore

Having them in link and js(d)link could also be useful (say when a widget would make a ajax request)

[Carreau]

IIRC it's already debounced/throttle, if there are more that 5 (IIRC) query pendings.

[maartenbreddels]

From what I understand from the code, it will not send 10 events at once after the kernel is finished, but just 1 (as is the default now).

This kind of throttling and debouncing is different (and debounce!=throttle), it is based on elapsed time since the first event. It will also be useful in combination with multithreading, as discussed here #642
It can also be done on the python side of course, though not as elegant, and requires attaching to the ioloop or some other async method. It makes more sense to implement in JS I think, to not send useless events to the kernel.

[hainm]

Two use cases:

add 3rd (my) case. I have an widget will update its state while user is typing in TextArea. Some operations are quite expensive, so I just want the TextArea updated every delay time.

[gnestor]

According to @jasongrout:

The sliders have a continuous_update option that [if set to False] only triggers a value change when the user stops dragging a slider: https://github.com/ipython/ipywidgets/blob/master/ipywidgets/widgets/widget_int.py#L156.

Related: #584

[gnestor]

I should also add that every widget has a msg_throttle key/property that can be set. According to the help: "msg_throttle: Maximum number of msgs the front-end can send before receiving an idle msg from the back-end."
https://github.com/ipython/ipywidgets/blob/eb4dcd9956d88ae842bff7822a9c32fc038906dd/ipywidgets/widgets/widget.py#L164

[maartenbreddels]

I currently have an 'ok' method to deal with this:

def debounced(delay_seconds=0.5, method=False):
    def wrapped(f):
        counters = collections.defaultdict(int)

        @functools.wraps(f)
        def execute(*args, **kwargs):
            if method: # if it is a method, we want to have a counter per instance
                key = args[0]
            else:
                key = None
            counters[key] += 1
            def debounced_execute(counter=counters[key]):
                if counter == counters[key]: # only execute if the counter wasn't changed in the meantime
                    f(*args, **kwargs)
            ioloop = get_ioloop()

            def thread_safe():
                ioloop.add_timeout(time.time() + delay_seconds, debounced_execute)

            ioloop.add_callback(thread_safe)
        return execute
    return wrapped

Use it like this:

@widgets.interact
@debounced(0.5)
def f(i=1):
    print(i)

Can also be used for methods, using method=True, I don't know an automatic way of testing the difference (I doubt it can be done).
Note that output does not get cleared, but you could do that manually, say:

from IPython.display import clear_output
@widgets.interact
@debounced(1)
def f(i=1, f=0.1):
    clear_output(wait=True)
    print(i,f)

[konwiddak]

Function or method can be auto detected.

https://docs.python.org/3/library/inspect.html#inspect.ismethod

inspect.ismethod(object)
Return true if the object is a bound method written in Python.

inspect.isfunction(object)
Return true if the object is a Python function, which includes functions created by a lambda expression.