Introduce skip_invalid argument to figure (#1162)

* Add skip_invalid kwarg to graph_objs constructors.

When set to True (Default is False) all invalid properties (invalid
by name or by value) will be skipped an no exception will be raised
due to schema violations.  The option applies recursively to all
child objects, but it only applies within the scope of the constructor.

* Add skip_invalid kwarg to Figure and FigureWidget.

Added docstring documentatin of skip_invalid, and added
new tests.

When set to True (Default is False) all invalid properties (invalid
by name or by value) will be skipped an no exception will be raised
due to schema violations.  The option applies recursively to all
child objects, but it only applies within the scope of the constructor.

Author: jonmmease

_plotly_utils/basevalidators.py

@@ -1890,18 +1890,21 @@ def description(self):
 
         return desc
 
-    def validate_coerce(self, v):
+    def validate_coerce(self, v, skip_invalid=False):
         if v is None:
             v = self.data_class()
 
         elif isinstance(v, dict):
-            v = self.data_class(**v)
+            v = self.data_class(skip_invalid=skip_invalid, **v)
 
         elif isinstance(v, self.data_class):
             # Copy object
-            v = self.data_class(**v.to_plotly_json())
+            v = self.data_class(v)
         else:
-            self.raise_invalid_val(v)
+            if skip_invalid:
+                v = self.data_class()
+            else:
+                self.raise_invalid_val(v)
 
         v._plotly_name = self.plotly_name
         return v
@@ -1948,7 +1951,7 @@ def data_class(self):
 
         return self._data_class
 
-    def validate_coerce(self, v):
+    def validate_coerce(self, v, skip_invalid=False):
 
         if v is None:
             v = []
@@ -1958,19 +1961,26 @@ def validate_coerce(self, v):
             invalid_els = []
             for v_el in v:
                 if isinstance(v_el, self.data_class):
-                    res.append(v_el)
+                    res.append(self.data_class(v_el))
                 elif isinstance(v_el, dict):
-                    res.append(self.data_class(**v_el))
+                    res.append(self.data_class(skip_invalid=skip_invalid,
+                                               **v_el))
                 else:
-                    res.append(None)
-                    invalid_els.append(v_el)
+                    if skip_invalid:
+                        res.append(self.data_class())
+                    else:
+                        res.append(None)
+                        invalid_els.append(v_el)
 
             if invalid_els:
                 self.raise_invalid_elements(invalid_els)
 
             v = to_scalar_or_list(res)
         else:
-            self.raise_invalid_val(v)
+            if skip_invalid:
+                v = []
+            else:
+                self.raise_invalid_val(v)
 
         return v
 
@@ -2032,7 +2042,7 @@ def class_map(self):
 
         return self._class_map
 
-    def validate_coerce(self, v):
+    def validate_coerce(self, v, skip_invalid=False):
 
         # Import Histogram2dcontour, this is the deprecated name of the
         # Histogram2dContour trace.
@@ -2062,14 +2072,26 @@ def validate_coerce(self, v):
                         trace_type = 'scatter'
 
                     if trace_type not in self.class_map:
-                        res.append(None)
-                        invalid_els.append(v_el)
+                        if skip_invalid:
+                            # Treat as scatter trace
+                            trace = self.class_map['scatter'](
+                                skip_invalid=skip_invalid, **v_copy)
+                            res.append(trace)
+                        else:
+                            res.append(None)
+                            invalid_els.append(v_el)
                     else:
-                        trace = self.class_map[trace_type](**v_copy)
+                        trace = self.class_map[trace_type](
+                            skip_invalid=skip_invalid, **v_copy)
                         res.append(trace)
                 else:
-                    res.append(None)
-                    invalid_els.append(v_el)
+                    if skip_invalid:
+                        # Add empty scatter trace
+                        trace = self.class_map['scatter']()
+                        res.append(trace)
+                    else:
+                        res.append(None)
+                        invalid_els.append(v_el)
 
             if invalid_els:
                 self.raise_invalid_elements(invalid_els)
@@ -2082,6 +2104,9 @@ def validate_coerce(self, v):
                     trace.uid = str(uuid.uuid1())
 
         else:
-            self.raise_invalid_val(v)
+            if skip_invalid:
+                v = []
+            else:
+                self.raise_invalid_val(v)
 
         return v

_plotly_utils/tests/validators/test_basetraces_validator.py

@@ -2,17 +2,27 @@
 from _plotly_utils.basevalidators import BaseDataValidator
 from plotly.graph_objs import Scatter, Bar, Box
 
+
 # Fixtures
 # --------
 @pytest.fixture()
 def validator():
     return BaseDataValidator(class_strs_map={'scatter': 'Scatter',
-                                        'bar': 'Bar',
-                                        'box': 'Box'},
+                                             'bar': 'Bar',
+                                             'box': 'Box'},
                              plotly_name='prop',
                              parent_name='parent',
                              set_uid=True)
 
+@pytest.fixture()
+def validator_nouid():
+    return BaseDataValidator(class_strs_map={'scatter': 'Scatter',
+                                             'bar': 'Bar',
+                                             'box': 'Box'},
+                             plotly_name='prop',
+                             parent_name='parent',
+                             set_uid=False)
+
 
 # Tests
 # -----
@@ -104,3 +114,30 @@ def test_rejection_element_tracetype(validator):
         validator.validate_coerce(val)
 
     assert "Invalid element(s)" in str(validation_failure.value)
+
+
+def test_skip_invalid(validator_nouid):
+    val = (dict(type='scatter',
+                mode='lines',
+                marker={'color': 'green',
+                        'bogus': 23},
+                line='bad_value'),
+           dict(type='box',
+                fillcolor='yellow',
+                bogus=111),
+           dict(type='bogus',
+                mode='lines+markers',
+                x=[2, 1, 3]))
+
+    expected = [dict(type='scatter',
+                     mode='lines',
+                     marker={'color': 'green'}),
+                dict(type='box',
+                     fillcolor='yellow'),
+                dict(type='scatter',
+                     mode='lines+markers',
+                     x=[2, 1, 3])]
+
+    res = validator_nouid.validate_coerce(val, skip_invalid=True)
+
+    assert [el.to_plotly_json() for el in res] == expected

_plotly_utils/tests/validators/test_compound_validator.py

@@ -59,3 +59,43 @@ def test_rejection_value(validator):
     assert ("Invalid property specified for object of type "
             "plotly.graph_objs.scatter.Marker: 'bogus'" in
             str(validation_failure.value))
+
+
+def test_skip_invalid(validator):
+    val = dict(
+        color='green',
+        size=10,
+        bogus=99,  # Bad property name
+        colorbar={'bgcolor': 'blue',
+                  'bogus_inner': 23  # Bad nested property name
+                  },
+        opacity='bogus value'  # Bad value for valid property
+    )
+
+    expected = dict(
+        color='green',
+        size=10,
+        colorbar={'bgcolor': 'blue'})
+
+    res = validator.validate_coerce(val, skip_invalid=True)
+    assert res.to_plotly_json() == expected
+
+
+def test_skip_invalid_empty_object(validator):
+    val = dict(
+        color='green',
+        size=10,
+        colorbar={'bgcolor': 'bad_color', # Bad value for valid property
+                  'bogus_inner': 23  # Bad nested property name
+                  },
+        opacity=0.5  # Bad value for valid property
+    )
+
+    # The colorbar property should be absent, not None or {}
+    expected = dict(
+        color='green',
+        size=10,
+        opacity=0.5)
+
+    res = validator.validate_coerce(val, skip_invalid=True)
+    assert res.to_plotly_json() == expected

_plotly_utils/tests/validators/test_compoundarray_validator.py

@@ -89,3 +89,20 @@ def test_rejection_value(validator):
     assert ("Invalid property specified for object of type "
             "plotly.graph_objs.layout.Image" in
             str(validation_failure.value))
+
+
+def test_skip_invalid(validator):
+    val = [dict(opacity='bad_opacity',
+                x=23,
+                sizex=120),
+           dict(x=99,
+                bogus={'a': 23},
+                sizey=300)]
+
+    expected = [dict(x=23,
+                     sizex=120),
+                dict(x=99,
+                     sizey=300)]
+
+    res = validator.validate_coerce(val, skip_invalid=True)
+    assert [el.to_plotly_json() for el in res] == expected

codegen/datatypes.py

@@ -221,6 +221,10 @@ def __init__(self""")
 constructor must be a dict or 
 an instance of {class_name}\"\"\")
 
+        # Handle skip_invalid
+        # -------------------
+        self._skip_invalid = kwargs.pop('skip_invalid', False)
+        
         # Import validators
         # -----------------
         from plotly.validators{node.parent_dotpath_str} import (
@@ -266,6 +270,10 @@ def __init__(self""")
         # Process unknown kwargs
         # ----------------------
         self._process_kwargs(**dict(arg, **kwargs))
+        
+        # Reset skip_invalid
+        # ------------------
+        self._skip_invalid = False
     """)
 
     # Return source string

codegen/figure.py

@@ -67,20 +67,35 @@ class {fig_classname}({base_classname}):\n""")
     frames_description = reindent_validator_description(frame_validator, 8)
 
     buffer.write(f"""
-    def __init__(self, data=None, layout=None, frames=None):
+    def __init__(self, data=None, layout=None,
+                 frames=None, skip_invalid=False):
         \"\"\"
         Create a new {fig_classname} instance
         
         Parameters
         ----------
         data
             {data_description}
+            
         layout
             {layout_description}
+            
         frames
             {frames_description}
+            
+        skip_invalid: bool
+            If True, invalid properties in the figure specification will be
+            skipped silently. If False (default) invalid properties in the
+            figure specification will result in a ValueError
+
+        Raises
+        ------
+        ValueError
+            if a property in the specification of data, layout, or frames
+            is invalid AND skip_invalid is False
         \"\"\"
-        super({fig_classname} ,self).__init__(data, layout, frames)
+        super({fig_classname} ,self).__init__(data, layout,
+                                              frames, skip_invalid)
     """)
 
     # ### add_trace methods for each trace type ###