def test_repeat():
# wrapped repeat
chart1 = alt.Chart('data.csv').mark_point().encode(
x=alt.X(alt.repeat(), type='quantitative'),
y='y:Q',
).repeat(
['A', 'B', 'C', 'D'],
columns=2
)
dct1 = chart1.to_dict()
assert dct1['repeat'] == ['A', 'B', 'C', 'D']
assert dct1['columns'] == 2
assert dct1['spec']['encoding']['x']['field'] == {'repeat': 'repeat'}
# explicit row/col repeat
chart2 = alt.Chart('data.csv').mark_point().encode(
x=alt.X(alt.repeat('row'), type='quantitative'),
y=alt.Y(alt.repeat('column'), type='quantitative')
).repeat(
row=['A', 'B', 'C'],
column=['C', 'B', 'A']
)
dct2 = chart2.to_dict()
assert dct2['repeat'] == {'row': ['A', 'B', 'C'], 'column': ['C', 'B', 'A']}
assert 'columns' not in dct2
assert dct2['spec']['encoding']['x']['field'] == {'repeat': 'row'}
assert dct2['spec']['encoding']['y']['field'] == {'repeat': 'column'}
def test_layer_errors():
toplevel_chart = alt.Chart("data.txt").mark_point().configure_legend(
columns=2)
facet_chart1 = alt.Chart("data.txt").mark_point().encode(facet="row:Q")
facet_chart2 = alt.Chart("data.txt").mark_point().facet("row:Q")
repeat_chart = alt.Chart("data.txt").mark_point().repeat(["A", "B", "C"])
simple_chart = alt.Chart("data.txt").mark_point()
with pytest.raises(ValueError) as err:
toplevel_chart + simple_chart
assert str(err.value).startswith(
'Objects with "config" attribute cannot be used within LayerChart.')
with pytest.raises(ValueError) as err:
repeat_chart + simple_chart
assert str(err.value) == "Repeat charts cannot be layered."
with pytest.raises(ValueError) as err:
facet_chart1 + simple_chart
assert str(err.value) == "Faceted charts cannot be layered."
with pytest.raises(ValueError) as err:
alt.layer(simple_chart) + facet_chart2
assert str(err.value) == "Faceted charts cannot be layered."
def test_consolidate_InlineData():
data = alt.InlineData(
values=[{'a': 1, 'b': 1}, {'a': 2, 'b': 2}],
format={'type': 'csv'}
)
chart = alt.Chart(data).mark_point()
with alt.data_transformers.enable(consolidate_datasets=False):
dct = chart.to_dict()
assert dct['data']['format'] == data.format
assert dct['data']['values'] == data.values
with alt.data_transformers.enable(consolidate_datasets=True):
dct = chart.to_dict()
assert dct['data']['format'] == data.format
assert list(dct['datasets'].values())[0] == data.values
data = alt.InlineData(
values=[],
name='runtime_data'
)
chart = alt.Chart(data).mark_point()
with alt.data_transformers.enable(consolidate_datasets=False):
dct = chart.to_dict()
assert dct['data'] == data.to_dict()
with alt.data_transformers.enable(consolidate_datasets=True):
dct = chart.to_dict()
assert dct['data'] == data.to_dict()
def test_consolidate_InlineData():
data = alt.InlineData(values=[{
"a": 1,
"b": 1
}, {
"a": 2,
"b": 2
}],
format={"type": "csv"})
chart = alt.Chart(data).mark_point()
with alt.data_transformers.enable(consolidate_datasets=False):
dct = chart.to_dict()
assert dct["data"]["format"] == data.format
assert dct["data"]["values"] == data.values
with alt.data_transformers.enable(consolidate_datasets=True):
dct = chart.to_dict()
assert dct["data"]["format"] == data.format
assert list(dct["datasets"].values())[0] == data.values
data = alt.InlineData(values=[], name="runtime_data")
chart = alt.Chart(data).mark_point()
with alt.data_transformers.enable(consolidate_datasets=False):
dct = chart.to_dict()
assert dct["data"] == data.to_dict()
with alt.data_transformers.enable(consolidate_datasets=True):
dct = chart.to_dict()
assert dct["data"] == data.to_dict()
def test_facet_basic():
# wrapped facet
chart1 = (alt.Chart("data.csv").mark_point().encode(
x="x:Q",
y="y:Q",
).facet("category:N", columns=2))
dct1 = chart1.to_dict()
assert dct1["facet"] == alt.Facet("category:N").to_dict()
assert dct1["columns"] == 2
assert dct1["data"] == alt.UrlData("data.csv").to_dict()
# explicit row/col facet
chart2 = (alt.Chart("data.csv").mark_point().encode(
x="x:Q",
y="y:Q",
).facet(row="category1:Q", column="category2:Q"))
dct2 = chart2.to_dict()
assert dct2["facet"]["row"] == alt.Facet("category1:Q").to_dict()
assert dct2["facet"]["column"] == alt.Facet("category2:Q").to_dict()
assert "columns" not in dct2
assert dct2["data"] == alt.UrlData("data.csv").to_dict()
def test_facet():
# wrapped facet
chart1 = alt.Chart('data.csv').mark_point().encode(
x='x:Q',
y='y:Q',
).facet(
'category:N',
columns=2
)
dct1 = chart1.to_dict()
assert dct1['facet'] == alt.Facet('category:N').to_dict()
assert dct1['columns'] == 2
assert dct1['data'] == alt.UrlData('data.csv').to_dict()
# explicit row/col facet
chart2 = alt.Chart('data.csv').mark_point().encode(
x='x:Q',
y='y:Q',
).facet(
row='category1:Q',
column='category2:Q'
)
dct2 = chart2.to_dict()
assert dct2['facet']['row'] == alt.Facet('category1:Q').to_dict()
assert dct2['facet']['column'] == alt.Facet('category2:Q').to_dict()
assert 'columns' not in dct2
assert dct2['data'] == alt.UrlData('data.csv').to_dict()
def test_chart_infer_types():
data = pd.DataFrame({'x': pd.date_range('2012', periods=10, freq='Y'),
'y': range(10),
'c': list('abcabcabca')})
def _check_encodings(chart):
dct = chart.to_dict()
assert dct['encoding']['x']['type'] == 'temporal'
assert dct['encoding']['x']['field'] == 'x'
assert dct['encoding']['y']['type'] == 'quantitative'
assert dct['encoding']['y']['field'] == 'y'
assert dct['encoding']['color']['type'] == 'nominal'
assert dct['encoding']['color']['field'] == 'c'
# Pass field names by keyword
chart = alt.Chart(data).mark_point().encode(x='x', y='y', color='c')
_check_encodings(chart)
# pass Channel objects by keyword
chart = alt.Chart(data).mark_point().encode(x=alt.X('x'), y=alt.Y('y'),
color=alt.Color('c'))
_check_encodings(chart)
# pass Channel objects by value
chart = alt.Chart(data).mark_point().encode(alt.X('x'), alt.Y('y'),
alt.Color('c'))
_check_encodings(chart)
# override default types
chart = alt.Chart(data).mark_point().encode(alt.X('x', type='nominal'),
alt.Y('y', type='ordinal'))
dct = chart.to_dict()
assert dct['encoding']['x']['type'] == 'nominal'
assert dct['encoding']['y']['type'] == 'ordinal'
def test_repeat():
# wrapped repeat
chart1 = (alt.Chart("data.csv").mark_point().encode(
x=alt.X(alt.repeat(), type="quantitative"),
y="y:Q",
).repeat(["A", "B", "C", "D"], columns=2))
dct1 = chart1.to_dict()
assert dct1["repeat"] == ["A", "B", "C", "D"]
assert dct1["columns"] == 2
assert dct1["spec"]["encoding"]["x"]["field"] == {"repeat": "repeat"}
# explicit row/col repeat
chart2 = (alt.Chart("data.csv").mark_point().encode(
x=alt.X(alt.repeat("row"), type="quantitative"),
y=alt.Y(alt.repeat("column"), type="quantitative"),
).repeat(row=["A", "B", "C"], column=["C", "B", "A"]))
dct2 = chart2.to_dict()
assert dct2["repeat"] == {
"row": ["A", "B", "C"],
"column": ["C", "B", "A"]
}
assert "columns" not in dct2
assert dct2["spec"]["encoding"]["x"]["field"] == {"repeat": "row"}
assert dct2["spec"]["encoding"]["y"]["field"] == {"repeat": "column"}
def test_subcharts_different_data(method, data):
func = getattr(alt, method)
point = alt.Chart(data).mark_point().encode(x="x:Q", y="y:Q")
otherdata = alt.Chart("data.csv").mark_point().encode(x="x:Q", y="y:Q")
nodata = alt.Chart().mark_point().encode(x="x:Q", y="y:Q")
chart1 = func(point, otherdata)
assert chart1.data is alt.Undefined
assert getattr(chart1, method)[0].data is data
chart2 = func(point, nodata)
assert chart2.data is alt.Undefined
assert getattr(chart2, method)[0].data is data
def test_chart_operations():
data = pd.DataFrame({
"x": pd.date_range("2012", periods=10, freq="Y"),
"y": range(10),
"c": list("abcabcabca"),
})
chart1 = alt.Chart(data).mark_line().encode(x="x", y="y", color="c")
chart2 = chart1.mark_point()
chart3 = chart1.mark_circle()
chart4 = chart1.mark_square()
chart = chart1 + chart2 + chart3
assert isinstance(chart, alt.LayerChart)
assert len(chart.layer) == 3
chart += chart4
assert len(chart.layer) == 4
chart = chart1 | chart2 | chart3
assert isinstance(chart, alt.HConcatChart)
assert len(chart.hconcat) == 3
chart |= chart4
assert len(chart.hconcat) == 4
chart = chart1 & chart2 & chart3
assert isinstance(chart, alt.VConcatChart)
assert len(chart.vconcat) == 3
chart &= chart4
assert len(chart.vconcat) == 4
def test_geo_interface_feature_collection_gdf():
geom = {
'bbox': (19.89, -26.82, 29.43, -17.66),
'features': [{
'bbox': (19.89, -26.82, 29.43, -17.66),
'geometry': {
'coordinates': [[[6.90, 53.48], [5.98, 51.85], [6.07, 53.51],
[6.90, 53.48]]],
'type':
'Polygon'
},
'id': '49',
'properties': {
'continent': 'Africa',
'gdp_md_est': 35900.0,
'id': 'BWA',
'iso_a3': 'BWA',
'name': 'Botswana',
'pop_est': 2214858
},
'type': 'Feature'
}],
'type':
'FeatureCollection'
}
feat = geom_obj(geom)
with alt.data_transformers.enable(consolidate_datasets=False):
spec = alt.Chart(feat).mark_geoshape().to_dict()
assert spec['data']['values'][0]['id'] == 'BWA'
def test_geo_interface_feature_collection_gdf():
geom = {
"bbox": (19.89, -26.82, 29.43, -17.66),
"features": [{
"bbox": (19.89, -26.82, 29.43, -17.66),
"geometry": {
"coordinates": [[[6.90, 53.48], [5.98, 51.85], [6.07, 53.51],
[6.90, 53.48]]],
"type":
"Polygon",
},
"id": "49",
"properties": {
"continent": "Africa",
"gdp_md_est": 35900.0,
"id": "BWA",
"iso_a3": "BWA",
"name": "Botswana",
"pop_est": 2214858,
},
"type": "Feature",
}],
"type":
"FeatureCollection",
}
feat = geom_obj(geom)
with alt.data_transformers.enable(consolidate_datasets=False):
spec = alt.Chart(feat).mark_geoshape().to_dict()
assert spec["data"]["values"][0]["id"] == "BWA"
def test_display_options():
chart = alt.Chart("data.csv").mark_point().encode(x="foo:Q")
# check that there are no options by default
with check_render_options():
chart.display()
# check that display options are passed
with check_render_options(embed_options={"tooltip": False, "renderer": "canvas"}):
chart.display("canvas", tooltip=False)
# check that above options do not persist
with check_render_options():
chart.display()
# check that display options augment rather than overwrite pre-set options
with alt.renderers.enable(embed_options={"tooltip": True, "renderer": "svg"}):
with check_render_options(embed_options={"tooltip": True, "renderer": "svg"}):
chart.display()
with check_render_options(
embed_options={"tooltip": True, "renderer": "canvas"}
):
chart.display("canvas")
# check that above options do not persist
with check_render_options():
chart.display()
def basic_chart():
data = pd.DataFrame({
'a': ['A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I'],
'b': [28, 55, 43, 91, 81, 53, 19, 87, 52]
})
return alt.Chart(data).mark_bar().encode(x='a', y='b')
def test_selection():
# test instantiation of selections
interval = alt.selection_interval(name="selec_1")
assert interval.selection.type == "interval"
assert interval.name == "selec_1"
single = alt.selection_single(name="selec_2")
assert single.selection.type == "single"
assert single.name == "selec_2"
multi = alt.selection_multi(name="selec_3")
assert multi.selection.type == "multi"
assert multi.name == "selec_3"
# test adding to chart
chart = alt.Chart().add_selection(single)
chart = chart.add_selection(multi, interval)
assert set(chart.selection.keys()) == {"selec_1", "selec_2", "selec_3"}
# test logical operations
assert isinstance(single & multi, alt.Selection)
assert isinstance(single | multi, alt.Selection)
assert isinstance(~single, alt.Selection)
assert isinstance((single & multi)[0].group, alt.SelectionAnd)
assert isinstance((single | multi)[0].group, alt.SelectionOr)
assert isinstance((~single)[0].group, alt.SelectionNot)
# test that default names increment (regression for #1454)
sel1 = alt.selection_single()
sel2 = alt.selection_multi()
sel3 = alt.selection_interval()
names = {s.name for s in (sel1, sel2, sel3)}
assert len(names) == 3
def test_selection_property():
sel = alt.selection_interval()
chart = alt.Chart('data.csv').mark_point().properties(
selection=sel
)
assert list(chart['selection'].keys()) == [sel.name]
def test_filter_transform_selection_predicates():
selector1 = alt.selection_interval(name='s1')
selector2 = alt.selection_interval(name='s2')
base = alt.Chart('data.txt').mark_point()
chart = base.transform_filter(selector1)
assert chart.to_dict()['transform'] == [{'filter': {'selection': 's1'}}]
chart = base.transform_filter(~selector1)
assert chart.to_dict()['transform'] == [{'filter': {'selection': {'not': 's1'}}}]
chart = base.transform_filter(selector1 & selector2)
assert chart.to_dict()['transform'] == [{'filter': {'selection': {'and': ['s1', 's2']}}}]
chart = base.transform_filter(selector1 | selector2)
assert chart.to_dict()['transform'] == [{'filter': {'selection': {'or': ['s1', 's2']}}}]
chart = base.transform_filter(selector1 | ~selector2)
assert chart.to_dict()['transform'] == [{'filter': {'selection': {'or': ['s1', {'not': 's2'}]}}}]
chart = base.transform_filter(~selector1 | ~selector2)
assert chart.to_dict()['transform'] == [{'filter': {'selection': {'or': [{'not': 's1'}, {'not': 's2'}]}}}]
chart = base.transform_filter(~(selector1 & selector2))
assert chart.to_dict()['transform'] == [{'filter': {'selection': {'not': {'and': ['s1', 's2']}}}}]
def _make_chart_type(chart_type):
data = pd.DataFrame({
'x': [28, 55, 43, 91, 81, 53, 19, 87],
'y': [43, 91, 81, 53, 19, 87, 52, 28],
'color': list('AAAABBBB'),
})
base = alt.Chart(data).mark_point().encode(
x='x',
y='y',
color='color',
)
if chart_type in ['layer', 'hconcat', 'vconcat', 'concat']:
func = getattr(alt, chart_type)
return func(base.mark_square(), base.mark_circle())
elif chart_type == 'facet':
return base.facet('color')
elif chart_type == 'facet_encoding':
return base.encode(facet='color')
elif chart_type == 'repeat':
return base.encode(
alt.X(alt.repeat(), type='quantitative')
).repeat(
['x', 'y']
)
elif chart_type == 'chart':
return base
else:
raise ValueError("chart_type='{}' is not recognized".format(chart_type))
def test_chart_operations():
data = pd.DataFrame({'x': pd.date_range('2012', periods=10, freq='Y'),
'y': range(10),
'c': list('abcabcabca')})
chart1 = alt.Chart(data).mark_line().encode(x='x', y='y', color='c')
chart2 = chart1.mark_point()
chart3 = chart1.mark_circle()
chart4 = chart1.mark_square()
chart = chart1 + chart2 + chart3
assert isinstance(chart, alt.LayerChart)
assert len(chart.layer) == 3
chart += chart4
assert len(chart.layer) == 4
chart = chart1 | chart2 | chart3
assert isinstance(chart, alt.HConcatChart)
assert len(chart.hconcat) == 3
chart |= chart4
assert len(chart.hconcat) == 4
chart = chart1 & chart2 & chart3
assert isinstance(chart, alt.VConcatChart)
assert len(chart.vconcat) == 3
chart &= chart4
assert len(chart.vconcat) == 4
def _make_chart_type(chart_type):
data = pd.DataFrame({
"x": [28, 55, 43, 91, 81, 53, 19, 87],
"y": [43, 91, 81, 53, 19, 87, 52, 28],
"color": list("AAAABBBB"),
})
base = (alt.Chart(data).mark_point().encode(
x="x",
y="y",
color="color",
))
if chart_type in ["layer", "hconcat", "vconcat", "concat"]:
func = getattr(alt, chart_type)
return func(base.mark_square(), base.mark_circle())
elif chart_type == "facet":
return base.facet("color")
elif chart_type == "facet_encoding":
return base.encode(facet="color")
elif chart_type == "repeat":
return base.encode(alt.X(alt.repeat(),
type="quantitative")).repeat(["x", "y"])
elif chart_type == "chart":
return base
else:
raise ValueError(
"chart_type='{}' is not recognized".format(chart_type))
def test_facet_parse_data():
data = pd.DataFrame({"x": range(5), "y": range(5), "row": list("abcab")})
chart = (alt.Chart(data).mark_point().encode(x="x", y="y:O").facet(
row="row", column="column:O"))
with alt.data_transformers.enable(consolidate_datasets=False):
dct = chart.to_dict()
assert "values" in dct["data"]
assert "data" not in dct["spec"]
assert dct["facet"] == {
"column": {
"field": "column",
"type": "ordinal"
},
"row": {
"field": "row",
"type": "nominal"
},
}
with alt.data_transformers.enable(consolidate_datasets=True):
dct = chart.to_dict()
assert "datasets" in dct
assert "name" in dct["data"]
assert "data" not in dct["spec"]
assert dct["facet"] == {
"column": {
"field": "column",
"type": "ordinal"
},
"row": {
"field": "row",
"type": "nominal"
},
}
def test_facet_parse_data():
data = pd.DataFrame({'x': range(5), 'y': range(5), 'row': list('abcab')})
chart = alt.Chart(data).mark_point().encode(x='x', y='y:O').facet(
row='row', column='column:O')
with alt.data_transformers.enable(consolidate_datasets=False):
dct = chart.to_dict()
assert 'values' in dct['data']
assert 'data' not in dct['spec']
assert dct['facet'] == {
'column': {
'field': 'column',
'type': 'ordinal'
},
'row': {
'field': 'row',
'type': 'nominal'
}
}
with alt.data_transformers.enable(consolidate_datasets=True):
dct = chart.to_dict()
assert 'datasets' in dct
assert 'name' in dct['data']
assert 'data' not in dct['spec']
assert dct['facet'] == {
'column': {
'field': 'column',
'type': 'ordinal'
},
'row': {
'field': 'row',
'type': 'nominal'
}
}
def basic_chart():
data = pd.DataFrame({
"a": ["A", "B", "C", "D", "E", "F", "G", "H", "I"],
"b": [28, 55, 43, 91, 81, 53, 19, 87, 52],
})
return alt.Chart(data).mark_bar().encode(x="a", y="b")
def test_chart_data_types():
Chart = lambda data: alt.Chart(data).mark_point().encode(x='x:Q', y='y:Q')
# Url Data
data = '/path/to/my/data.csv'
dct = Chart(data).to_dict()
assert dct['data'] == {'url': data}
# Dict Data
data = {"values": [{"x": 1, "y": 2}, {"x": 2, "y": 3}]}
with alt.data_transformers.enable(consolidate_datasets=False):
dct = Chart(data).to_dict()
assert dct['data'] == data
with alt.data_transformers.enable(consolidate_datasets=True):
dct = Chart(data).to_dict()
name = dct['data']['name']
assert dct['datasets'][name] == data['values']
# DataFrame data
data = pd.DataFrame({"x": range(5), "y": range(5)})
with alt.data_transformers.enable(consolidate_datasets=False):
dct = Chart(data).to_dict()
assert dct['data']['values'] == data.to_dict(orient='records')
with alt.data_transformers.enable(consolidate_datasets=True):
dct = Chart(data).to_dict()
name = dct['data']['name']
assert dct['datasets'][name] == data.to_dict(orient='records')
# Named data object
data = alt.NamedData(name='Foo')
dct = Chart(data).to_dict()
assert dct['data'] == {'name': 'Foo'}
def test_compound_add_selections(charttype):
base = alt.Chart("data.csv").mark_point()
selection = alt.selection_single()
chart1 = charttype(base.add_selection(selection),
base.add_selection(selection))
chart2 = charttype(base, base).add_selection(selection)
assert chart1.to_dict() == chart2.to_dict()
def test_geo_interface_serializing_arrays_tuples():
import array as arr
geom = {
"bbox": arr.array("d", [1, 2, 3, 4]),
"geometry": {
"coordinates": [
tuple((
tuple((6.90, 53.48)),
tuple((5.98, 51.85)),
tuple((6.07, 53.51)),
tuple((6.90, 53.48)),
))
],
"type":
"Polygon",
},
"id": 27,
"properties": {},
"type": "Feature",
}
feat = geom_obj(geom)
with alt.data_transformers.enable(consolidate_datasets=False):
spec = alt.Chart(feat).mark_geoshape().to_dict()
assert spec["data"]["values"]["geometry"]["coordinates"][0][0] == [
6.9, 53.48
]
def test_geo_interface_empty_feature_collection():
geom = {"type": "FeatureCollection", "features": []}
feat = geom_obj(geom)
with alt.data_transformers.enable(consolidate_datasets=False):
spec = alt.Chart(feat).mark_geoshape().to_dict()
assert spec['data']['values'] == []
def test_filter_transform_selection_predicates():
selector1 = alt.selection_interval(name="s1")
selector2 = alt.selection_interval(name="s2")
base = alt.Chart("data.txt").mark_point()
chart = base.transform_filter(selector1)
assert chart.to_dict()["transform"] == [{"filter": {"selection": "s1"}}]
chart = base.transform_filter(~selector1)
assert chart.to_dict()["transform"] == [{"filter": {"selection": {"not": "s1"}}}]
chart = base.transform_filter(selector1 & selector2)
assert chart.to_dict()["transform"] == [
{"filter": {"selection": {"and": ["s1", "s2"]}}}
]
chart = base.transform_filter(selector1 | selector2)
assert chart.to_dict()["transform"] == [
{"filter": {"selection": {"or": ["s1", "s2"]}}}
]
chart = base.transform_filter(selector1 | ~selector2)
assert chart.to_dict()["transform"] == [
{"filter": {"selection": {"or": ["s1", {"not": "s2"}]}}}
]
chart = base.transform_filter(~selector1 | ~selector2)
assert chart.to_dict()["transform"] == [
{"filter": {"selection": {"or": [{"not": "s1"}, {"not": "s2"}]}}}
]
chart = base.transform_filter(~(selector1 & selector2))
assert chart.to_dict()["transform"] == [
{"filter": {"selection": {"not": {"and": ["s1", "s2"]}}}}
]
def test_geo_interface_polygon_feature():
geom = {
"coordinates": [[(0, 0), (0, 2), (2, 2), (2, 0), (0, 0)]],
"type": "Polygon"
}
feat = geom_obj(geom)
with alt.data_transformers.enable(consolidate_datasets=False):
spec = alt.Chart(feat).mark_geoshape().to_dict()
assert spec['data']['values']['type'] == 'Feature'
def test_add_selection():
selections = [
alt.selection_interval(),
alt.selection_single(),
alt.selection_multi(),
]
chart = (alt.Chart().mark_point().add_selection(
selections[0]).add_selection(selections[1], selections[2]))
expected = {s.name: s.selection for s in selections}
assert chart.selection == expected
