Allow color array properties to be N-dimensional

This is needed to support the `table.cells.fill.color` and `table.cells.line.color` properties

Author: jonmmease

Diff for: _plotly_utils/basevalidators.py

@@ -116,6 +116,13 @@ def is_homogeneous_array(v):
             (pd and isinstance(v, pd.Series)))
 
 
+def is_homogeneous_ndarray(v):
+    """
+    Return whether a value is considered to be a homogeneous array
+    """
+    return np and isinstance(v, np.ndarray)
+
+
 def is_simple_array(v):
     """
     Return whether a value is considered to be an simple array
@@ -984,56 +991,78 @@ def description(self):
 
         return valid_color_description
 
-    def validate_coerce(self, v):
+    def validate_coerce(self, v, should_raise=True):
         if v is None:
             # Pass None through
             pass
-        elif self.array_ok and is_homogeneous_array(v):
+        elif self.array_ok and (
+                is_homogeneous_array(v) or
+                is_homogeneous_ndarray(v)):
+
             v_array = copy_to_readonly_numpy_array(v)
             if (self.numbers_allowed() and
                     v_array.dtype.kind in ['u', 'i', 'f']):
                 # Numbers are allowed and we have an array of numbers.
                 # All good
                 v = v_array
             else:
-                validated_v = [self.vc_scalar(e) for e in v]
+                validated_v = [
+                    self.validate_coerce(e, should_raise=False)
+                    for e in v]
 
-                invalid_els = [
-                    el for el, validated_el in zip(v, validated_v)
-                    if validated_el is None
-                ]
-                if invalid_els:
+                invalid_els = self.find_invalid_els(v, validated_v)
+
+                if invalid_els and should_raise:
                     self.raise_invalid_elements(invalid_els)
 
                 # ### Check that elements have valid colors types ###
-                if self.numbers_allowed():
+                elif self.numbers_allowed() or invalid_els:
                     v = copy_to_readonly_numpy_array(
                         validated_v, dtype='object')
                 else:
                     v = copy_to_readonly_numpy_array(
                         validated_v, dtype='unicode')
         elif self.array_ok and is_simple_array(v):
-            validated_v = [self.vc_scalar(e) for e in v]
+            validated_v = [
+                self.validate_coerce(e, should_raise=False)
+                for e in v]
 
-            invalid_els = [
-                el for el, validated_el in zip(v, validated_v)
-                if validated_el is None
-            ]
+            invalid_els = self.find_invalid_els(v, validated_v)
 
-            if invalid_els:
+            if invalid_els and should_raise:
                 self.raise_invalid_elements(invalid_els)
-
-            v = validated_v
+            else:
+                v = validated_v
         else:
             # Validate scalar color
             validated_v = self.vc_scalar(v)
-            if validated_v is None:
+            if validated_v is None and should_raise:
                 self.raise_invalid_val(v)
 
             v = validated_v
 
         return v
 
+    def find_invalid_els(self, orig, validated, invalid_els=None):
+        """
+        Helper method to find invalid elements in orig array.
+        Elements are invalid if their corresponding element in
+        the validated array is None.
+
+        This method handles deeply nested list structures
+        """
+        if invalid_els is None:
+            invalid_els = []
+
+        for orig_el, validated_el in zip(orig, validated):
+            if is_array(orig_el):
+                self.find_invalid_els(orig_el, validated_el, invalid_els)
+            else:
+                if validated_el is None:
+                    invalid_els.append(orig_el)
+
+        return invalid_els
+
     def vc_scalar(self, v):
         """ Helper to validate/coerce a scalar color """
         return ColorValidator.perform_validate_coerce(

Diff for: _plotly_utils/tests/validators/test_color_validator.py

@@ -105,6 +105,23 @@ def test_acceptance_aok(val, validator_aok: ColorValidator):
         assert coerce_val == val
 
 
+@pytest.mark.parametrize('val', [
+    'green',
+    [['blue']],
+    [['red', 'rgb(255, 0, 0)'], ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)']],
+    np.array([['red', 'rgb(255, 0, 0)'], ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)']])
+])
+def test_acceptance_aok_2D(val, validator_aok: ColorValidator):
+    coerce_val = validator_aok.validate_coerce(val)
+
+    if isinstance(val, np.ndarray):
+        assert np.array_equal(coerce_val, val)
+    elif isinstance(val, list):
+        assert validator_aok.present(coerce_val) == tuple(val)
+    else:
+        assert coerce_val == val
+
+
 # ### Rejection ###
 @pytest.mark.parametrize('val',
                          [[23], [0, 1, 2],
@@ -118,6 +135,20 @@ def test_rejection_aok(val, validator_aok: ColorValidator):
     assert 'Invalid element(s)' in str(validation_failure.value)
 
 
+@pytest.mark.parametrize('val',
+                         [[['redd', 'rgb(255, 0, 0)']],
+                          [['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)'],
+                           ['hsv(0, 100%, 100%)', 'purple']],
+                          [np.array(['hsl(0, 100%, 50_00%)', 'hsla(0, 100%, 50%, 100%)']),
+                           np.array(['hsv(0, 100%, 100%)', 'purple'])],
+                          [['blue'], [2]]])
+def test_rejection_aok_2D(val, validator_aok: ColorValidator):
+    with pytest.raises(ValueError) as validation_failure:
+        validator_aok.validate_coerce(val)
+
+    assert 'Invalid element(s)' in str(validation_failure.value)
+
+
 # Array ok, numbers ok
 # --------------------
 # ### Acceptance ###