Keeping previous inputted values after cell reevaluation

[pslacerda]

I'd like to keep the previous inputted widget values even after the cell was reevaluated.

[jasongrout]

Can you give an example of a cell you'd like to evaluate multiple times, but keep widget values around?

If you are creating new widgets in the code cell, the values will need to be in the code of the cell (they are completely new widgets, after all). If you are just displaying widgets that you've already created, the values should reflect what was input.

[pslacerda]

My the cell has many input widgets and while developing the plotting logic I change the widget values to something more reasonable. Sometimes I need to change inputs for edge cases and preserve a few and than change it again keep for more a few times.

Maybe I should really change the input not within ipywidgets while developing.

I was thinking about hashing the widget tree and refill with the previous preserved state if the tree was the same.

I just wanted to keep previous input values. Thought that would be possible. Another question is how to to evaluate interact_manual automatically just after cell evaluation, and then behave as expected? Probably I'm just learning notebooks, but seems that these features would ease the development.

[jasongrout]

One approach is to fiddle with things interactively, then print out the necessary values and change the input to match. Getting this sort of workflow to work well is tricky, and we don't have a really good way of easily doing what you describe. Guessing the user intent is also hard - perhaps I'm reevaluating the cell because I want to start fresh.

I think I recently saw a similar approach somewhere: a user would fiddle with a plot, and automatically the code would be written that would reflect the changes. The user then copies that code into the input cell to preserve the changes. In the past, in a different project, we also implemented something similar to what you describe - the user fiddles with things and then can easily access the state tree, and then there was also a convenience function for setting widget values from the state tree (but it still relied on the user explicitly preserving the state tree).

I'm not sure I understand what you mean by evaluating interact_manual automatically. Can you describe more concretely with an example what you are saying?

[pslacerda]

I did something like an wrapper around interact that set a SimpleNamespace with input values. Then in another cell I could plot as much as I need because the namespace was already set and preserved. Was a "interact cell" to input values.

About evaluating interact_manual automatically:

@interact_manual
def plot(a=(1, 10)
         b=(2, 20)):
    if tricky_code:
        while developing(a):
            debugging(b)

Everytime I evaluate a cell that has interact_manual I want to "run interact" just after, maybe is a common approach. After that I would press "run interact" only when needed. There is such option?

[jasongrout]

I did something like an wrapper around interact that set a SimpleNamespace with input values. Then in another cell I could plot as much as I need because the namespace was already set and preserved. Was a "interact cell" to input values.

Taking that idea a bit further (or maybe in a slightly different direction), we had the concept of multiple "bookmarks" of parameter values in the Sage Cell. This was helpful in teaching, where we wanted to demonstrate several different settings and easily switch between them. Maybe interesting experiment would be creating a wrapper widget that allows you to save parameter values for children widgets as a series of bookmarks, switch between them, and easily serialize these bookmarks. Then you can copy the serialized versions of these bookmarks to an input to preserve them across kernel restarts. (Or if you only care about having the bookmarks preserved in a single session, perhaps you just start your bookmarking container in another cell, and reuse it in the cell you are reevaluating).

[jasongrout]

I've opened #2299 about the interact_manual issue.

[pslacerda]

Bookmarks would be very welcomed as it serves exactly one of our needs. We have some parameter sets to filter our data. I appreciate prefilled value sets, even if it would be useful only as an educational tool or for presentations.

For development, hash the widget tree to detect widget changes and refill values seems very handy. The values would be preserved at some global state, I'm sure JupyterLab has some.

@interact_bookmark(
    preserve_values=True,
    set_1={'param': 2},
    set_2={'param': 9})
def function(param=(1, 10)):
    pass

Would clash only if someone wants a bookmark named "preserve_values", which would look very unusual for me.

Serialize current values and save as a bookmark seems very handy for notebook users analysing data by themselves.

[pslacerda]

Maybe to bookmark a parameter set should automatically persist the serialized representation on disk, and reevaluate the cell would load all bookmarks automatically.

Anyway what would happen when the widgets were changed and bookmarks loaded? What Sage Cell does in such situation?