Add optional validation using go.validate object as callable of context manager

Author: jonmmease

packages/python/plotly/_plotly_utils/basevalidators.py

@@ -2457,6 +2457,10 @@ def validate_coerce(self, v, skip_invalid=False):
         v._plotly_name = self.plotly_name
         return v
 
+    def present(self, v):
+        # Return compound object as-is
+        return v
+
 
 class TitleValidator(CompoundValidator):
     """
@@ -2551,6 +2555,10 @@ def validate_coerce(self, v, skip_invalid=False):
 
         return v
 
+    def present(self, v):
+        # Return compound object as tuple
+        return tuple(v)
+
 
 class BaseDataValidator(BaseValidator):
     def __init__(

packages/python/plotly/plotly/_validate.py

@@ -0,0 +1,12 @@
+class validate(object):
+    _should_validate = True
+
+    def __init__(self, should_validate):
+        self._old = validate._should_validate
+        validate._should_validate = should_validate
+
+    def __enter__(self):
+        pass
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        validate._should_validate = self._old

packages/python/plotly/plotly/basedatatypes.py

@@ -10,11 +10,7 @@
 from copy import deepcopy, copy
 
 from _plotly_utils.utils import _natural_sort_strings
-from plotly.subplots import (
-    _set_trace_grid_reference,
-    _get_grid_subplot,
-    _get_subplot_ref_for_trace,
-)
+from plotly._validate import validate
 from .optional_imports import get_module
 
 from _plotly_utils.basevalidators import (
@@ -3070,6 +3066,9 @@ def _process_kwargs(self, **kwargs):
             if k in self:
                 # e.g. underscore kwargs like marker_line_color
                 self[k] = v
+            elif not validate._should_validate:
+                # Set extra property as-is
+                self[k] = v
             else:
                 invalid_kwargs[k] = v
 
@@ -3551,24 +3550,49 @@ def __setitem__(self, prop, value):
             # ### Unwrap scalar tuple ###
             prop = prop[0]
 
-            # ### Validate prop ###
-            if prop not in self._validators:
-                self._raise_on_invalid_property_error(prop)
+            if validate._should_validate:
+                if prop not in self._valid_props:
+                    self._raise_on_invalid_property_error(prop)
 
-            # ### Get validator for this property ###
-            validator = self._validators[prop]
+                # ### Get validator for this property ###
+                validator = self._get_validator(prop)
 
-            # ### Handle compound property ###
-            if isinstance(validator, CompoundValidator):
-                self._set_compound_prop(prop, value)
+                # ### Handle compound property ###
+                if isinstance(validator, CompoundValidator):
+                    self._set_compound_prop(prop, value)
 
-            # ### Handle compound array property ###
-            elif isinstance(validator, (CompoundArrayValidator, BaseDataValidator)):
-                self._set_array_prop(prop, value)
+                # ### Handle compound array property ###
+                elif isinstance(validator, (CompoundArrayValidator, BaseDataValidator)):
+                    self._set_array_prop(prop, value)
 
-            # ### Handle simple property ###
+                # ### Handle simple property ###
+                else:
+                    self._set_prop(prop, value)
             else:
-                self._set_prop(prop, value)
+                # Make sure properties dict is initialized
+                self._init_props()
+
+                if isinstance(value, BasePlotlyType):
+                    # Extract json from graph objects
+                    value = value.to_plotly_json()
+
+                # Check for list/tuple of graph objects
+                if (
+                    isinstance(value, (list, tuple))
+                    and value
+                    and isinstance(value[0], BasePlotlyType)
+                ):
+                    value = [
+                        v.to_plotly_json() if isinstance(v, BasePlotlyType) else v
+                        for v in value
+                    ]
+
+                self._props[prop] = value
+
+                # Remove any already constructed graph object so that it will be
+                # reconstructed on property access
+                self._compound_props.pop(prop, None)
+                self._compound_array_props.pop(prop, None)
 
         # Handle non-scalar case
         # ----------------------

packages/python/plotly/plotly/tests/test_core/test_graph_objs/test_validate.py

@@ -0,0 +1,48 @@
+import plotly.graph_objs as go
+import json
+import pytest
+import plotly.io as pio
+
+
+def build_invalid_fig():
+    return go.Figure(
+        data=[{"type": "bar", "y": "not_a_list", "bogus": 23}],
+        layout_title_text="valid title",
+        layout_colorway="not a dict",
+    )
+
+
+expected_invalid_dict = dict(
+    data=[{"type": "bar", "y": "not_a_list", "bogus": 23}],
+    layout={"title": {"text": "valid title"}, "colorway": "not a dict"},
+)
+
+
+def test_validate_false():
+    template = pio.templates.default
+    should_validate = go.validate._should_validate
+    try:
+        pio.templates.default = None
+
+        # Build figure with variety of invalid properties (both name and value),
+        # make sure underscore notation is still applied properly
+        with go.validate(False):
+            fig = build_invalid_fig()
+            assert json.loads(fig.to_json()) == expected_invalid_dict
+
+        with go.validate(True):
+            with pytest.raises(ValueError):
+                build_invalid_fig()
+
+        # Use validate as callable
+        go.validate(False)
+        fig = build_invalid_fig()
+        assert json.loads(fig.to_json()) == expected_invalid_dict
+
+        go.validate(True)
+        with pytest.raises(ValueError):
+            build_invalid_fig()
+
+    finally:
+        pio.templates.default = template
+        go.validate(should_validate)