Pulling updated widget values from front-end

[hannorein]

Summary:

Add the examples in #1287 (comment) and #1287 (comment) to the docs as an advanced example for having a request/reply pattern with widgets using generator-like syntax

Original issue

I can check for updates to a widget value using observe:

import ipywidgets as widgets
from IPython.display import display
import time

w = widgets.Dropdown(
    options=['Addition', 'Multiplication', 'Subtraction'],
    value='Addition',
    description='Task:',
)

def on_change(change):
    print("changed to %s" % change['new'])

w.observe(on_change)

display(w)

But how can I do that during another operation, for example:

for i in range(100):
    time.sleep(1)
    # pull for changes to w here.
    # if w.has_changed:
    #     print(w.value)

I tried doing something like

import IPython
ipython = IPython.get_ipython()
ipython.kernel.do_one_iteration()

to pull for updates. But is seems unreliable. Is there a better way to do this?

[jasongrout]

We don't have a good way to poll for updates. Fundamentally, we're working on top of the kernel messaging protocol, and updates are messages that have to be processed like any other message, which in Python can't happen while the current code is running. Furthermore, the problem is fundamentally asynchronous, so it calls for a different approach. That said, you may have some luck doing an async/await construct to structure your async code as if it were synchronous.

[hannorein]

Thanks. I tried to play around with aync/wait but no luck so far. Is there any other way I can send data from javascript to python and wait for it to arrive? It doesn't seem like such a crazy workflow. Maybe I could hijack the web server and have my own web socket... (never mind, I don't think that'll work. for the same reason)

[jasongrout]

Is there any other way I can send data from javascript to python and wait for it to arrive?

There isn't infrastructure to deal with having python code pause execution and wait for events from javascript (except for the raw_input/input python builtin functions to get raw strings from the front end). Options for dealing with this include: (a) using a callback-based system, i.e., register a callback to continue your code and end your current execution, or (b) start another thread with your computation and return from the main thread and use some sort of locking primitive and a callback handler on the main thread to unblock the other thread, or (c) do some async/await magic to make the callback-based system in (a) look like synchronous code (I think this would work...).

CCing @minrk in case he has ideas too.

Can you elaborate on what you are trying to do? There may be a more natural way to accomplish your end goal.

[jasongrout]

(labeling as no action for now since we're still in a discussion about how to do things)

[hannorein]

@jasongrout In short: I have an interactive widget that visualizes an N-body simulation with WebGL. I'd like to allow the user to take a screenshot of the WebGL canvas while the simulation is running. For that, I need to send the data back from JS to python, save it to a file and only then continue running the simulation.

I now found a workaround using the observe callback that works (more or less, the syntax is a bit ugly). Basically what I'm doing is integrating the simulation to the first time where I want a screenshot, then setting up a callback function so I get notified when the screenshot data arrives. And then I'm restarting the simulation in the callback function until the next output.

[jasongrout]

In bqplot, we do this same thing completely client-side. There is a button near the rendered plot, and when the user clicks the button, it downloads the png through their web browser, rather than transferring it back to the kernel. The kernel knows nothing about the screenshot.

That means it is impossible to programmatically control the screenshot. If you need that, your way of doing it is the callback-oriented approach, which is probably the cleanest way right now.

CC @dmadeka, @ssunkara1.

[hannorein]

Ok. Thanks. Yes, I have to do it programmatically if I want to capture thousands of frames to render a movie. (the rendering, transfer and saving of images is really fast, by the way).

[jasongrout]

It would be interesting to see if we could come up with an async/await solution. Also, I think @takluyver was working on an asynchronous kernel - that could be useful here too.

[takluyver]

Might be @Carreau that you're thinking of.

[jasongrout]

Might be @Carreau that you're thinking of.

Ah yes, thanks!

[jasongrout]

The async kernel mentioned above is here: ipython/ipython#10390