Making numpy an optional dependency

Lists/tuples assigned to array properties are no longer coerced into
arrays. Instead they are stored internally as lists and converted to
tuples on property access (+1 squashed commit)
Squashed commits:

Author: Jon M. Mease

_plotly_utils/basevalidators.py

@@ -27,10 +27,25 @@ def test_acceptance(val, validator: AnyValidator):
 
 # ### Acceptance of arrays ###
 @pytest.mark.parametrize('val', [
-    [], np.array([]), ['Hello', 'World'], [np.pi, np.e, {}]
+    23,
+    'Hello!',
+    [],
+    (),
+    np.array([]),
+    ('Hello', 'World'),
+    ['Hello', 'World'],
+    [np.pi, np.e, {}]
 ])
 def test_acceptance_array(val, validator_aok: AnyValidator):
     coerce_val = validator_aok.validate_coerce(val)
-    assert isinstance(coerce_val, np.ndarray)
-    assert coerce_val.dtype == 'object'
-    assert np.array_equal(coerce_val, val)
+    if isinstance(val, np.ndarray):
+        assert isinstance(coerce_val, np.ndarray)
+        assert coerce_val.dtype == 'object'
+        assert np.array_equal(coerce_val, val)
+    elif isinstance(val, (list, tuple)):
+        assert coerce_val == list(val)
+        assert validator_aok.present(coerce_val) == tuple(val)
+    else:
+        assert coerce_val == val
+        assert validator_aok.present(coerce_val) == val
+

_plotly_utils/tests/validators/test_any_validator.py

@@ -18,46 +18,53 @@ def validator():
 def test_acceptance(validator: BaseDataValidator):
     val = [Scatter(mode='lines'), Box(fillcolor='yellow')]
     res = validator.validate_coerce(val)
+    res_present = validator.present(res)
 
-    assert isinstance(res, tuple)
-    assert isinstance(res[0], Scatter)
-    assert res[0].type == 'scatter'
-    assert res[0].mode == 'lines'
+    assert isinstance(res, list)
+    assert isinstance(res_present, tuple)
 
-    assert isinstance(res[1], Box)
-    assert res[1].type == 'box'
-    assert res[1].fillcolor == 'yellow'
+    assert isinstance(res_present[0], Scatter)
+    assert res_present[0].type == 'scatter'
+    assert res_present[0].mode == 'lines'
+
+    assert isinstance(res_present[1], Box)
+    assert res_present[1].type == 'box'
+    assert res_present[1].fillcolor == 'yellow'
 
     # Make sure UIDs are actually unique
-    assert res[0].uid != res[1].uid
+    assert res_present[0].uid != res_present[1].uid
 
 
 def test_acceptance_dict(validator: BaseDataValidator):
     val = (dict(type='scatter', mode='lines'),
            dict(type='box', fillcolor='yellow'))
     res = validator.validate_coerce(val)
+    res_present = validator.present(res)
 
-    assert isinstance(res, tuple)
-    assert isinstance(res[0], Scatter)
-    assert res[0].type == 'scatter'
-    assert res[0].mode == 'lines'
+    assert isinstance(res, list)
+    assert isinstance(res_present, tuple)
+    assert isinstance(res_present[0], Scatter)
+    assert res_present[0].type == 'scatter'
+    assert res_present[0].mode == 'lines'
 
-    assert isinstance(res[1], Box)
-    assert res[1].type == 'box'
-    assert res[1].fillcolor == 'yellow'
+    assert isinstance(res_present[1], Box)
+    assert res_present[1].type == 'box'
+    assert res_present[1].fillcolor == 'yellow'
 
     # Make sure UIDs are actually unique
-    assert res[0].uid != res[1].uid
+    assert res_present[0].uid != res_present[1].uid
 
 
 def test_default_is_scatter(validator: BaseDataValidator):
     val = [dict(mode='lines')]
     res = validator.validate_coerce(val)
+    res_present = validator.present(res)
 
-    assert isinstance(res, tuple)
-    assert isinstance(res[0], Scatter)
-    assert res[0].type == 'scatter'
-    assert res[0].mode == 'lines'
+    assert isinstance(res, list)
+    assert isinstance(res_present, tuple)
+    assert isinstance(res_present[0], Scatter)
+    assert res_present[0].type == 'scatter'
+    assert res_present[0].mode == 'lines'
 
 
 def test_rejection_type(validator: BaseDataValidator):

_plotly_utils/tests/validators/test_basetraces_validator.py

@@ -90,13 +90,17 @@ def test_rejection_colorscale(val, validator_colorscale: ColorValidator):
 @pytest.mark.parametrize('val',
                          ['blue',
                           ['red', 'rgb(255, 0, 0)'],
+                          np.array(['red', 'rgb(255, 0, 0)']),
                           ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'],
+                          np.array(['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)']),
                           ['hsva(0, 100%, 100%, 50%)']])
 def test_acceptance_aok(val, validator_aok: ColorValidator):
     coerce_val = validator_aok.validate_coerce(val)
 
-    if isinstance(val, (list, np.ndarray)):
+    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
 

_plotly_utils/tests/validators/test_color_validator.py

@@ -0,0 +1,47 @@
+import pytest
+import numpy as np
+
+from _plotly_utils.basevalidators import ColorlistValidator
+
+
+# Fixtures
+# --------
+@pytest.fixture()
+def validator():
+    return ColorlistValidator('prop', 'parent')
+
+
+# Rejection
+# ---------
+@pytest.mark.parametrize('val',
+                         [set(), 23, 0.5, {}, 'redd'])
+def test_rejection_value(validator, val):
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert 'Invalid value' in str(validation_failure.value)
+
+
+@pytest.mark.parametrize('val',
+                         [[set()], [23, 0.5], [{}, 'red'],
+                          ['blue', 'redd']])
+def test_rejection_element(validator, val):
+    with pytest.raises(ValueError) as validation_failure:
+        validator.validate_coerce(val)
+
+    assert 'Invalid element(s)' in str(validation_failure.value)
+
+
+# Acceptance
+# ----------
+@pytest.mark.parametrize('val',
+                         [['blue'],
+                          ['red', 'rgb(255, 0, 0)'],
+                          np.array(['red', 'rgb(255, 0, 0)']),
+                          ['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)'],
+                          np.array(['hsl(0, 100%, 50%)', 'hsla(0, 100%, 50%, 100%)', 'hsv(0, 100%, 100%)']),
+                          ['hsva(0, 100%, 100%, 50%)']])
+def test_acceptance_aok(val, validator):
+    coerce_val = validator.validate_coerce(val)
+    assert isinstance(coerce_val, list)
+    assert validator.present(coerce_val) == tuple(val)

_plotly_utils/tests/validators/test_colorlist_validator.py

@@ -20,8 +20,12 @@ def named_colorscale(request):
 # -----
 # ### Acceptance by name ###
 def test_acceptance_named(named_colorscale, validator: ColorscaleValidator):
+    # As-is
     assert validator.validate_coerce(named_colorscale) == named_colorscale
 
+    # Uppercase
+    assert (validator.validate_coerce(named_colorscale.upper()) ==
+           named_colorscale.upper())
 
 # ### Acceptance as array ###
 @pytest.mark.parametrize('val', [
@@ -32,31 +36,21 @@ def test_acceptance_named(named_colorscale, validator: ColorscaleValidator):
 def test_acceptance_array(val, validator: ColorscaleValidator):
     assert validator.validate_coerce(val) == val
 
-
-# ### Coercion of scale names ###
-def test_coercion_named(named_colorscale, validator: ColorscaleValidator):
-    # As is
-    assert validator.validate_coerce(named_colorscale) == named_colorscale
-
-    # Uppercase
-    assert validator.validate_coerce(
-        named_colorscale.upper()) == named_colorscale
-
-    # Lowercase
-    assert validator.validate_coerce(
-        named_colorscale.lower()) == named_colorscale
-
-
 # ### Coercion as array ###
 @pytest.mark.parametrize('val', [
     ([0, 'red'],),
     [(0.1, 'rgb(255, 0, 0)'), (0.3, 'GREEN')],
     (np.array([0, 'Purple'], dtype='object'), (0.2, 'yellow'), (1.0, 'RGBA(255,0,0,100)')),
 ])
 def test_acceptance_array(val, validator: ColorscaleValidator):
-    # Compute expected (tuple of tuples where color is lowercase with no spaces)
-    expected = tuple([tuple([e[0], e[1]]) for e in val])
-    assert validator.validate_coerce(val) == expected
+    # Compute expected (tuple of tuples where color is
+    # lowercase with no spaces)
+    expected = [[e[0], e[1]] for e in val]
+    coerce_val = validator.validate_coerce(val)
+    assert coerce_val == expected
+
+    expected_present = tuple([tuple(e) for e in expected])
+    assert validator.present(coerce_val) == expected_present
 
 
 # ### Rejection by type ###

_plotly_utils/tests/validators/test_colorscale_validator.py

@@ -16,44 +16,49 @@ def validator():
 def test_acceptance(validator: CompoundArrayValidator):
     val = [Image(opacity=0.5, sizex=120), Image(x=99)]
     res = validator.validate_coerce(val)
+    res_present = validator.present(res)
+    assert isinstance(res, list)
+    assert isinstance(res_present, tuple)
+    assert isinstance(res_present[0], Image)
+    assert res_present[0].opacity == 0.5
+    assert res_present[0].sizex == 120
+    assert res_present[0].x is None
 
-    assert isinstance(res, tuple)
-    assert isinstance(res[0], Image)
-    assert res[0].opacity == 0.5
-    assert res[0].sizex == 120
-    assert res[0].x is None
-
-    assert isinstance(res[1], Image)
-    assert res[1].opacity is None
-    assert res[1].sizex is None
-    assert res[1].x == 99
+    assert isinstance(res_present[1], Image)
+    assert res_present[1].opacity is None
+    assert res_present[1].sizex is None
+    assert res_present[1].x == 99
 
 
 def test_acceptance_empty(validator: CompoundArrayValidator):
     val = [{}]
     res = validator.validate_coerce(val)
+    res_present = validator.present(res)
 
-    assert isinstance(res, tuple)
-    assert isinstance(res[0], Image)
-    assert res[0].opacity is None
-    assert res[0].sizex is None
-    assert res[0].x is None
+    assert isinstance(res, list)
+    assert isinstance(res_present, tuple)
+    assert isinstance(res_present[0], Image)
+    assert res_present[0].opacity is None
+    assert res_present[0].sizex is None
+    assert res_present[0].x is None
 
 
 def test_acceptance_dict(validator: CompoundArrayValidator):
     val = [dict(opacity=0.5, sizex=120), dict(x=99)]
     res = validator.validate_coerce(val)
+    res_present = validator.present(res)
 
-    assert isinstance(res, tuple)
-    assert isinstance(res[0], Image)
-    assert res[0].opacity == 0.5
-    assert res[0].sizex == 120
-    assert res[0].x is None
+    assert isinstance(res, list)
+    assert isinstance(res_present, tuple)
+    assert isinstance(res_present[0], Image)
+    assert res_present[0].opacity == 0.5
+    assert res_present[0].sizex == 120
+    assert res_present[0].x is None
 
     assert isinstance(res[1], Image)
-    assert res[1].opacity is None
-    assert res[1].sizex is None
-    assert res[1].x == 99
+    assert res_present[1].opacity is None
+    assert res_present[1].sizex is None
+    assert res_present[1].x == 99
 
 
 def test_rejection_type(validator: CompoundArrayValidator):

_plotly_utils/tests/validators/test_compoundarray_validator.py

@@ -1,7 +1,7 @@
 import pytest
 from _plotly_utils.basevalidators import DataArrayValidator
 import numpy as np
-
+import pandas as pd
 
 # Fixtures
 # --------
@@ -14,17 +14,26 @@ def validator():
 # -----
 # ### Acceptance ###
 @pytest.mark.parametrize('val', [
-    [], [1], np.array([2, 3, 4]), [''], (), ('Hello, ',  'world!')
+    [], [1], [''], (), ('Hello, ',  'world!'), ['A', 1, 'B', 0, 'C']
+])
+def test_validator_acceptance_simple(val, validator: DataArrayValidator):
+    coerce_val = validator.validate_coerce(val)
+    assert isinstance(coerce_val, list)
+    assert validator.present(coerce_val) == tuple(val)
+
+
+@pytest.mark.parametrize('val', [
+    np.array([2, 3, 4]), pd.Series(['a', 'b', 'c'])
 ])
-def test_validator_acceptance(val, validator: DataArrayValidator):
+def test_validator_acceptance_homogeneous(val, validator: DataArrayValidator):
     coerce_val = validator.validate_coerce(val)
     assert isinstance(coerce_val, np.ndarray)
-    assert np.array_equal(coerce_val, val)
+    assert np.array_equal(validator.present(coerce_val), val)
 
 
 # ### Rejection ###
 @pytest.mark.parametrize('val', [
-    'Hello', 23, set(), {},
+    'Hello', 23, set(), {}, np.array([[1, 2, 3], [4, 5, 6]])
 ])
 def test_rejection(val, validator: DataArrayValidator):
     with pytest.raises(ValueError) as validation_failure:

_plotly_utils/tests/validators/test_dataarray_validator.py

@@ -1,5 +1,6 @@
 import pytest
 import numpy as np
+import pandas as pd
 from _plotly_utils.basevalidators import EnumeratedValidator
 
 
@@ -111,14 +112,19 @@ def test_rejection_by_element_aok(val, validator_aok):
 # ### Acceptance ###
 @pytest.mark.parametrize('val',
                          ['foo', 'bar12', 'bar21',
-                          [], ['bar12'], ['foo', 'bar012', 'baz']])
+                          [], ['bar12'], ('foo', 'bar012', 'baz'),
+                          np.array([]),
+                          np.array(['bar12']),
+                          np.array(['foo', 'bar012', 'baz'])])
 def test_acceptance_aok(val, validator_aok_re):
     # Values should be accepted and returned unchanged
     coerce_val = validator_aok_re.validate_coerce(val)
-    if isinstance(val, (list, np.ndarray)):
+    if isinstance(val, (np.ndarray, pd.Series)):
         assert np.array_equal(coerce_val, np.array(val, dtype=coerce_val.dtype))
+    elif isinstance(val, (list, tuple)):
+        assert validator_aok_re.present(coerce_val) == tuple(val)
     else:
-        assert coerce_val == val
+        assert validator_aok_re.present(coerce_val) == val
 
 
 # ### Reject by elements ###

_plotly_utils/tests/validators/test_enumerated_validator.py

@@ -136,16 +136,22 @@ def test_acceptance_aok_list_flaglist(val, validator_extra_aok: FlaglistValidato
 
 
 # ### Coercion ###
-@pytest.mark.parametrize('in_val,coerce_val',
+@pytest.mark.parametrize('in_val,expected',
                          [(['  lines ', ' lines + markers ', 'lines ,markers'],
-                           np.array(['lines', 'lines+markers', 'lines+markers'], dtype='unicode')
-                           ),
+                           ['lines', 'lines+markers', 'lines+markers']),
                           (np.array(['text   +lines']),
-                           np.array(['text+lines'], dtype='unicode')
-                           )
+                           np.array(['text+lines'], dtype='unicode'))
                           ])
-def test_coercion_aok(in_val, coerce_val, validator_extra_aok):
-    assert np.array_equal(validator_extra_aok.validate_coerce(in_val), coerce_val)
+def test_coercion_aok(in_val, expected, validator_extra_aok):
+    coerce_val = validator_extra_aok.validate_coerce(in_val)
+    if isinstance(in_val, (list, tuple)):
+        expected == coerce_val
+        validator_extra_aok.present(coerce_val) == tuple(expected)
+    else:
+        assert np.array_equal(coerce_val, coerce_val)
+        assert np.array_equal(
+            validator_extra_aok.present(coerce_val),
+            coerce_val)
 
 
 # ### Rejection by type ###