Fix tests

Author: kdorr

mplaltair/__init__.py

@@ -62,11 +62,11 @@ def _handle_line(chart, ax):
     groups = []
     kwargs = {}
 
-    if chart.encoding['opacity']:
+    if chart.encoding.get('opacity'):
         groups.append('opacity')
-    if chart.encoding['stroke']:
+    if chart.encoding.get('stroke'):
         groups.append('stroke')
-    elif chart.encoding['color']:
+    elif chart.encoding.get('color'):
         groups.append('color')
 
     list_fields = lambda c, g: [chart.encoding[i].field for i in g]

mplaltair/_axis.py

@@ -229,18 +229,3 @@ def convert_axis(ax, chart):
         _set_tick_locator(channel, ax)
         _set_tick_formatter(channel, ax)
         _set_label_angle(channel, ax)
-
-    # for channel in chart.to_dict()['encoding']:
-    #     if channel in ['x', 'y']:
-    #         chart_info = {'ax': ax, 'axis': channel,
-    #                       'data': _locate_channel_data(chart, channel),
-    #                       'dtype': _locate_channel_dtype(chart, channel),
-    #                       'mark': chart.mark}
-    #
-    #         scale_info = _locate_channel_scale(chart, channel)
-    #         axis_info = _locate_channel_axis(chart, channel)
-    #
-    #         # _set_limits(chart_info, scale_info)
-    #         _set_tick_locator(chart_info, axis_info)
-    #         _set_tick_formatter(chart_info, axis_info)
-    #         _set_label_angle(chart_info, axis_info)

mplaltair/parse_chart.py

@@ -85,6 +85,12 @@ class ChartMetadata(object):
     """
 
     def __init__(self, alt_chart):
+
+        if not alt_chart.to_dict()['mark']:
+            raise ValueError("Mark not provided")
+        if not alt_chart.to_dict().get('encoding'):
+            raise ValueError("Ranged encoding channels like x2, y2 not allowed for Mark: {}".format(alt_chart.mark))
+
         _normalize_data(alt_chart)
         self.data = alt_chart.data
         self.mark = alt_chart.mark

mplaltair/tests/test_axis.py

@@ -3,6 +3,8 @@
 import matplotlib.pyplot as plt
 import pandas as pd
 from mplaltair import convert
+from .._axis import convert_axis
+from parse_chart import ChartMetadata
 import pytest
 
 df_quant = pd.DataFrame({
@@ -50,7 +52,8 @@ def test_axis_set_tick_formatter_fail():
      This test is just for temporary coverage purposes."""
     from .._axis import _set_tick_formatter
     _, ax = plt.subplots()
-    _set_tick_formatter({'ax': ax, 'dtype': 'ordinal'}, {})
+    chart = ChartMetadata(alt.Chart(df_quant).mark_point().encode('a:N', 'c:O'))
+    _set_tick_formatter(chart.encoding['x'], ax)
 
 
 @pytest.mark.mpl_image_compare(baseline_dir='baseline_images/test_axis')

mplaltair/tests/test_convert.py

@@ -6,6 +6,7 @@
 import matplotlib.pyplot as plt
 from mplaltair import convert
 from mplaltair._convert import _convert
+from mplaltair.parse_chart import ChartMetadata
 
 
 df = pd.DataFrame({
@@ -22,170 +23,175 @@
 })
 
 
-def test_encoding_not_provided():
+def test_encoding_not_provided():  # TODO: move to the parse_chart tests
     chart_spec = alt.Chart(df).mark_point()
     with pytest.raises(ValueError):
-        _convert(chart_spec)
+        chart = ChartMetadata(chart_spec)
+        # _convert(chart)
 
 def test_invalid_encodings():
     chart_spec = alt.Chart(df).encode(x2='quant').mark_point()
+    chart = ChartMetadata(chart_spec)
     with pytest.raises(ValueError):
-        _convert(chart_spec)
+        _convert(chart)
 
 @pytest.mark.xfail(raises=TypeError)
-def test_invalid_temporal():
+def test_invalid_temporal():  # TODO: move to parse_chart tests???
     chart = alt.Chart(df).mark_point().encode(alt.X('quant:T'))
-    _convert(chart)
+    ChartMetadata(chart)
+    # _convert(chart)
 
 @pytest.mark.parametrize('channel', ['quant', 'ord', 'nom'])
 def test_convert_x_success(channel):
     chart_spec = alt.Chart(df).encode(x=channel).mark_point()
-    mapping = _convert(chart_spec)
+    chart = ChartMetadata(chart_spec)
+    mapping = _convert(chart)
     assert list(mapping['x']) == list(df[channel].values)
 
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_x_success_temporal(column):
     chart = alt.Chart(df).mark_point().encode(alt.X(column))
+    chart = ChartMetadata(chart)
     mapping = _convert(chart)
     assert list(mapping['x']) == list(mdates.date2num(df[column].values))
 
 def test_convert_x_fail():
-    chart_spec = alt.Chart(df).encode(x='b:N').mark_point()
     with pytest.raises(KeyError):
+        chart_spec = ChartMetadata(alt.Chart(df).encode(x='b:N').mark_point())
         _convert(chart_spec)
 
 @pytest.mark.parametrize('channel', ['quant', 'ord', 'nom'])
 def test_convert_y_success(channel):
-    chart_spec = alt.Chart(df).encode(y=channel).mark_point()
+    chart_spec = ChartMetadata(alt.Chart(df).encode(y=channel).mark_point())
     mapping = _convert(chart_spec)
     assert list(mapping['y']) == list(df[channel].values)
 
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_y_success_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Y(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Y(column)))
     mapping = _convert(chart)
     assert list(mapping['y']) == list(mdates.date2num(df[column].values))
 
 def test_convert_y_fail():
-    chart_spec = alt.Chart(df).encode(y='b:N').mark_point()
     with pytest.raises(KeyError):
+        chart_spec = ChartMetadata(alt.Chart(df).encode(y='b:N').mark_point())
         _convert(chart_spec)
 
 @pytest.mark.xfail(raises=ValueError, reason="It doesn't make sense to have x2 and y2 on scatter plots")
 def test_quantitative_x2_y2():
-    chart = alt.Chart(df_quant).mark_point().encode(alt.X('a'), alt.Y('b'), alt.X2('c'), alt.Y2('alpha'))
+    chart = ChartMetadata(alt.Chart(df_quant).mark_point().encode(alt.X('a'), alt.Y('b'), alt.X2('c'), alt.Y2('alpha')))
     _convert(chart)
 
 @pytest.mark.xfail(raises=ValueError)
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_x2_y2_fail_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.X2(column), alt.Y2(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.X2(column), alt.Y2(column)))
     _convert(chart)
 
 @pytest.mark.parametrize('channel,dtype', [('quant','quantitative'), ('ord','ordinal')])
 def test_convert_color_success(channel, dtype):
-    chart_spec = alt.Chart(df).encode(color=alt.Color(field=channel, type=dtype)).mark_point()
+    chart_spec = ChartMetadata(alt.Chart(df).encode(color=alt.Color(field=channel, type=dtype)).mark_point())
     mapping = _convert(chart_spec)
     assert list(mapping['c']) == list(df[channel].values)
 
 def test_convert_color_success_nominal():
-    chart_spec = alt.Chart(df).encode(color='nom').mark_point()
+    chart_spec = ChartMetadata(alt.Chart(df).encode(color='nom').mark_point())
     with pytest.raises(NotImplementedError):
         _convert(chart_spec)
 
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_color_success_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Color(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Color(column)))
     mapping = _convert(chart)
     assert list(mapping['c']) == list(mdates.date2num(df[column].values))
 
-def test_convert_color_fail():
-    chart_spec = alt.Chart(df).encode(color='b:N').mark_point()
+def test_convert_color_fail():  # TODO: What is this covering?
     with pytest.raises(KeyError):
+        chart_spec = ChartMetadata(alt.Chart(df).encode(color='b:N').mark_point())
         _convert(chart_spec)
 
 @pytest.mark.parametrize('channel,type', [('quant', 'Q'), ('ord', 'O')])
 def test_convert_fill(channel, type):
-    chart_spec = alt.Chart(df).encode(fill='{}:{}'.format(channel, type)).mark_point()
+    chart_spec = ChartMetadata(alt.Chart(df).encode(fill='{}:{}'.format(channel, type)).mark_point())
     mapping = _convert(chart_spec)
     assert list(mapping['c']) == list(df[channel].values)
 
 def test_convert_fill_success_nominal():
-    chart_spec = alt.Chart(df).encode(fill='nom').mark_point()
+    chart_spec = ChartMetadata(alt.Chart(df).encode(fill='nom').mark_point())
     with pytest.raises(NotImplementedError):
         _convert(chart_spec)
 
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_fill_success_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Fill(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Fill(column)))
     mapping = _convert(chart)
     assert list(mapping['c']) == list(mdates.date2num(df[column].values))
 
 
-def test_convert_fill_fail():
-    chart_spec = alt.Chart(df).encode(fill='b:N').mark_point()
+def test_convert_fill_fail():  # TODO: what is this covering?
     with pytest.raises(KeyError):
+        chart_spec = ChartMetadata(alt.Chart(df).encode(fill='b:N').mark_point())
         _convert(chart_spec)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="The marker argument in scatter() cannot take arrays")
 def test_quantitative_shape():
-    chart = alt.Chart(df_quant).mark_point().encode(alt.Shape('shape'))
+    chart = ChartMetadata(alt.Chart(df_quant).mark_point().encode(alt.Shape('shape')))
     mapping = _convert(chart)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="The marker argument in scatter() cannot take arrays")
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_shape_fail_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Shape(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Shape(column)))
     mapping = _convert(chart)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="Merge: the dtype for opacity isn't assumed to be quantitative")
 def test_quantitative_opacity_value():
-    chart = alt.Chart(df_quant).mark_point().encode(opacity=alt.value(.5))
+    chart = ChartMetadata(alt.Chart(df_quant).mark_point().encode(opacity=alt.value(.5)))
     mapping = _convert(chart)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="The alpha argument in scatter() cannot take arrays")
 def test_quantitative_opacity_array():
-    chart = alt.Chart(df_quant).mark_point().encode(alt.Opacity('alpha'))
+    chart = ChartMetadata(alt.Chart(df_quant).mark_point().encode(alt.Opacity('alpha')))
     _convert(chart)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="The alpha argument in scatter() cannot take arrays")
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_opacity_fail_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Opacity(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Opacity(column)))
     _convert(chart)
 
 @pytest.mark.parametrize('channel,type', [('quant', 'Q'), ('ord', 'O')])
 def test_convert_size_success(channel, type):
-    chart_spec = alt.Chart(df).encode(size='{}:{}'.format(channel, type)).mark_point()
+    chart_spec = ChartMetadata(alt.Chart(df).encode(size='{}:{}'.format(channel, type)).mark_point())
     mapping = _convert(chart_spec)
     assert list(mapping['s']) == list(df[channel].values)
 
 def test_convert_size_success_nominal():
-    chart_spec = alt.Chart(df).encode(size='nom').mark_point()
     with pytest.raises(NotImplementedError):
+        chart_spec = ChartMetadata(alt.Chart(df).encode(size='nom').mark_point())
         _convert(chart_spec)
 
 def test_convert_size_fail():
-    chart_spec = alt.Chart(df).encode(size='b:N').mark_point()
     with pytest.raises(KeyError):
+        chart_spec = ChartMetadata(alt.Chart(df).encode(size='b:N').mark_point())
         _convert(chart_spec)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="Dates would need to be normalized for the size.")
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_size_fail_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Size(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Size(column)))
     _convert(chart)
 
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="Stroke is not well supported in Altair")
 def test_quantitative_stroke():
-    chart = alt.Chart(df_quant).mark_point().encode(alt.Stroke('fill'))
+    chart = ChartMetadata(alt.Chart(df_quant).mark_point().encode(alt.Stroke('fill')))
     _convert(chart)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="Stroke is not well defined in Altair")
 @pytest.mark.parametrize("column", ["years", "months", "days", "hrs", "combination"])
 def test_convert_stroke_fail_temporal(column):
-    chart = alt.Chart(df).mark_point().encode(alt.Stroke(column))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.Stroke(column)))
     _convert(chart)
 
 
@@ -194,12 +200,12 @@ def test_convert_stroke_fail_temporal(column):
 @pytest.mark.xfail(raises=NotImplementedError, reason="Aggregate functions are not supported yet")
 def test_quantitative_x_count_y():
     df_count = pd.DataFrame({"a": [1, 1, 2, 3, 5], "b": [1.4, 1.4, 2.9, 3.18, 5.3]})
-    chart = alt.Chart(df_count).mark_point().encode(alt.X('a'), alt.Y('count()'))
+    chart = ChartMetadata(alt.Chart(df_count).mark_point().encode(alt.X('a'), alt.Y('count()')))
     mapping = _convert(chart)
 
 @pytest.mark.xfail(raises=NotImplementedError, reason="specifying timeUnit is not supported yet")
 def test_timeUnit():
-    chart = alt.Chart(df).mark_point().encode(alt.X('date(combination)'))
+    chart = ChartMetadata(alt.Chart(df).mark_point().encode(alt.X('date(combination)')))
     _convert(chart)
 
 # Plots

mplaltair/tests/test_data.py

@@ -36,9 +36,6 @@ def test_data_field_quantitative(column, dtype):
     chart = alt.Chart(df).mark_point().encode(alt.X(field=column, type=dtype))
     for channel in chart.to_dict()['encoding']:
         data = _data._locate_channel_data(chart, channel)
-    if dtype == 'temporal':
-        assert list(data) == list(_data._convert_to_mpl_date(df[column].values))
-    else:
         assert list(data) == list(df[column].values)
 
 
@@ -54,7 +51,7 @@ def test_data_shorthand_temporal():
     chart = alt.Chart(df).mark_point().encode(alt.X('combination'))
     for channel in chart.to_dict()['encoding']:
         data = _data._locate_channel_data(chart, channel)
-    assert list(data) == list(_data._convert_to_mpl_date(df['combination'].values))
+    assert list(data) == list(df['combination'].values)
 
 
 def test_data_value_quantitative():