Store component breaks with nested data.

[bcliang]

The Store component should support serialization and deserialization of standard python variable types (JSON.stringify() and JSON.parse()). However, the component does not properly validate the data if it is a dictionary with keys comprising of either lists or additional dicts:

• return dict(mykey=[])
• return dict(mykey = dict())

The data is saved properly to session/local storage (I did not try memory), but fails after componentUpdate. I didn't dig into it, but believe this is a result of how the dataCheck function evaluates this type of data structure against what is already stored (always returns true, data has changed). End result is that modified_timestamp callback is triggered in an infinite loop.

function dataCheck(data, old) { ... }

I'm currently working around this issue by serializing the information myself rather than relying on the built-in handler.
return json.dumps(dict(mykey=[]))

See below for a demo. Issue applies to empty/non-empty lists/dicts.

import json
import dash
import dash_html_components as html
import dash_core_components as dcc
from dash.dependencies import Input, Output, State

app = dash.Dash(__name__)


app.layout = html.Div([
    dcc.Store(
        id='store',
        storage_type='local'
    ),
    html.Button(
        id='btn1',
        children='break me'
    ),
    html.Button(
        id='btn2',
        children='pre-serialize (safe)'
    ),
    html.Div(id='output')
])


@app.callback(
    Output('store', 'data'),
    [Input('btn1', 'n_clicks'),
     Input('btn2', 'n_clicks')],
    [State('btn1', 'n_clicks_timestamp'),
     State('btn2', 'n_clicks_timestamp')]
)
def unsafe_click(n_clicks1, n_clicks2, tm_clicks1, tm_clicks2):
    if n_clicks1 is None and n_clicks2 is None:
        raise dash.exceptions.PreventUpdate

    data = dict(key=[])  # dict(key=dict())
    tm_clicks1 = tm_clicks1 or -1
    tm_clicks2 = tm_clicks2 or -1
    if tm_clicks2 > tm_clicks1:
        data = json.dumps(data)

    return data


@app.callback(
    Output('output', 'children'),
    [Input('store', 'modified_timestamp')],
    [State('store', 'data')]
)
def add_to_storage(timestamp, data):
    if timestamp is None:
        raise dash.exceptions.PreventUpdate

    print('current storage is {}'.format(data))
    print('modified_timestamp is {}'.format(timestamp))

    return json.dumps(data)


if __name__ == '__main__':
    app.run_server(debug=True, threaded=True, port=3033)

[T4rk1n]

Can you post the demo as an example with backticks formatting.

[T4rk1n]

dict as key is invalid in python, dict are unhashable.

[T4rk1n]

List are also unhashable, you would need a tuple as key.

[bcliang]

Ok, so the hash is used to check whether data is new, so the types must not be mutable. In the implementation, dict types are supported, but only as long as everything inside is immutable.

Since I am saving lists of data, for now I will stick with json.dumps() and loads(). I guess you are saying that I could also use frozenset(dict_to_save) and dict(loaded_frozenset).

[T4rk1n]

A dict is basically a hash table, it associate a hashable type with a pointer to an object in memory. To be hashable, you need to implement __eq__ and __hash__. __hash__ must return a long, same as calling hash(obj).

I personally wouldn't use anything else than a string or int as key in the store data as it is used in transport (shared between js and python that have different type handling). If you need complex keys, consider concatenating some instance variables in a string separated by '-' or something.

[bcliang]

Just to confirm you're talking about the value stored in a (key, value) pair of a dict, right? Yeah, I will serialize value to string within the callback function. My specific use case was to dump my data, of the form dict(timestamp, x, y).

I chose "key=.." as a dirty example in my code. The following also breaks.

    data = dict(my_dictionary_key=[1,2,3])  # dict(my_dictionary_key=dict())
    return data

[T4rk1n]

There's indeed an error with nested objects/list when there's an Input with the timestamp. Thanks for reporting, I'll work on it.

[chriddyp]

It would be great if we could catch the fact that we can only handle dictionaries with string keys inside our new validation (plotly/dash#340) (cc @rmarren1 )

In some cases, our JS casting sort of "just works", for example in the dcc.Slider:

dcc.Slider(
    min=0,
    max=10,
    marks={
        0: '0 °F',
        3: '3 °F',
        5: '5 °F',
        7.65: '7.65 °F',
        10: '10 °F'
    },
    value=5
)

The keys for marks are numbers but they'll get stringified on transport.

But beyond that case, many users have used complex objects as keys in their object and it'd be nice to catch that early.

[rmarren1]

This is do-able with Cerberus: http://docs.python-cerberus.org/en/stable/validation-rules.html#keyschema.

We can add validation for all dict properties that the keys must be a number or string.