More informative JSON not serializable errors with paths.

Author: rmarren1

dash/dash.py

@@ -475,6 +475,62 @@ def _validate_callback(self, output, inputs, state, events):
                 output.component_id,
                 output.component_property).replace('    ', ''))
 
+    def _validate_callback_output(self, output_value, output):
+        valid = [str, dict, int, float, type(None), Component, dict]
+
+        def _raise_invalid(bad_val, outer_type, bad_type, path, index=None):
+            raise exceptions.ReturnValueNotJSONSerializable('''
+            The callback for property `{:s}` of component `{:s}`
+            returned a tree with one value having type `{:s}`
+            which is not JSON serializable.
+
+            The value in question is located at
+
+            `{:s}`
+
+            and has string representation
+
+            `{}`.
+
+            In general, Dash properties can only be
+            dash components, strings, dictionaries, numbers, None,
+            or lists of those.
+            '''.format(
+                output.component_property,
+                output.component_id,
+                bad_type,
+                (
+                    "outer list index {:d} ({:s}) -> "
+                    .format(index, outer_type)
+                    if index is not None
+                    else (outer_type + " -> ")
+                ) + path,
+                bad_val).replace('    ', ''))
+
+        def _value_is_valid(val):
+            return (
+                # pylint: disable=unused-variable
+                any([isinstance(val, x) for x in valid]) or
+                type(val).__name__ == 'unicode'
+            )
+
+        def _validate_value(val, index=None):
+            if isinstance(val, Component):
+                for p, j in val.traverse_with_paths():
+                    if not _value_is_valid(j):
+                        _raise_invalid(j, type(val).__name__, type(j).__name__,
+                                       p, index)
+            else:
+                if not _value_is_valid(val):
+                    _raise_invalid(val, type(val).__name__, type(val).__name__,
+                                   '', index)
+
+        if isinstance(output_value, list):
+            for i, val in enumerate(output_value):
+                _validate_value(val, index=i)
+        elif isinstance(output_value, Component):
+            _validate_value(output_value)
+
     # TODO - Update nomenclature.
     # "Parents" and "Children" should refer to the DOM tree
     # and not the dependency tree.
@@ -513,6 +569,7 @@ def wrap_func(func):
             def add_context(*args, **kwargs):
 
                 output_value = func(*args, **kwargs)
+                self._validate_callback_output(output_value, output)
                 response = {
                     'response': {
                         'props': {

dash/development/base_component.py

@@ -151,22 +151,33 @@ def __delitem__(self, id):  # pylint: disable=redefined-builtin
 
     def traverse(self):
         """Yield each item in the tree."""
+        for t in self.traverse_with_paths():
+            yield t[1]
+
+    def traverse_with_paths(self):
+        """Yield each item with its path in the tree."""
         children = getattr(self, 'children', None)
+        children_type = type(children).__name__
 
         # children is just a component
         if isinstance(children, Component):
-            yield children
-            for t in children.traverse():
-                yield t
+            yield children_type, children
+            for p, t in children.traverse_with_paths():
+                yield " -> ".join([children_type, p]), t
 
         # children is a list of components
         elif isinstance(children, collections.MutableSequence):
-            for i in children:  # pylint: disable=not-an-iterable
-                yield i
+            for idx, i in enumerate(children):
+                list_path = "{:s} index {:d} (type {:s})".format(
+                    children_type,
+                    idx,
+                    type(i).__name__
+                )
+                yield list_path, i
 
                 if isinstance(i, Component):
-                    for t in i.traverse():
-                        yield t
+                    for p, t in i.traverse_with_paths():
+                        yield " -> ".join([list_path, p]), t
 
     def __iter__(self):
         """Yield IDs in the tree of children."""

dash/exceptions.py

@@ -44,3 +44,7 @@ class CantHaveMultipleOutputs(CallbackException):
 
 class PreventUpdate(CallbackException):
     pass
+
+
+class ReturnValueNotJSONSerializable(CallbackException):
+    pass