def test_update_list_empty(self):
trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2])
trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1])
fig = Figure([trace1, trace2])
fig.update([])
d1, d2 = strip_dict_params(fig.data[0], Scatter(x=[1, 2, 3], y=[2, 1, 2]))
assert d1 == d2
d1, d2 = strip_dict_params(fig.data[1], Scatter(x=[1, 2, 3], y=[3, 2, 1]))
assert d1 == d2
def test_update_dict_empty(self):
trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2])
trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1])
fig = Figure([trace1, trace2])
update_res = fig.update({})
d1, d2 = strip_dict_params(fig.data[0],
Scatter(x=[1, 2, 3], y=[2, 1, 2]))
assert d1 == d2
d1, d2 = strip_dict_params(fig.data[1],
Scatter(x=[1, 2, 3], y=[3, 2, 1]))
assert d1 == d2
assert update_res is fig
def test_toplevel_dict(self):
d1, d2 = strip_dict_params(self.scatter['marker'], {})
assert d1 == d2
self.scatter['marker'] = dict(color='yellow', size=10)
assert isinstance(self.scatter['marker'], go.scatter.Marker)
d1, d2 = strip_dict_params(self.scatter.marker,
self.expected_toplevel['marker'])
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def test_toplevel_dict(self):
d1, d2 = strip_dict_params(self.scatter["marker"], {})
assert d1 == d2
self.scatter["marker"] = dict(color="yellow", size=10)
assert isinstance(self.scatter["marker"], go.scatter.Marker)
d1, d2 = strip_dict_params(
self.scatter.marker, self.expected_toplevel["marker"]
)
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def test_nested_dict_dot(self):
d1, d2 = strip_dict_params(self.scatter.marker.colorbar, {})
assert d1 == d2
self.scatter["marker.colorbar"] = dict(bgcolor="yellow", thickness=5)
assert isinstance(self.scatter["marker.colorbar"], go.scatter.marker.ColorBar)
d1, d2 = strip_dict_params(
self.scatter["marker.colorbar"], self.expected_nested["marker"]["colorbar"]
)
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_dict_dot(self):
d1, d2 = strip_dict_params(self.scatter.marker.colorbar, {})
assert d1 == d2
self.scatter['marker.colorbar'] = dict(bgcolor='yellow', thickness=5)
assert isinstance(self.scatter['marker.colorbar'],
go.scatter.marker.ColorBar)
d1, d2 = strip_dict_params(self.scatter['marker.colorbar'],
self.expected_nested['marker']['colorbar'])
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_update_dict(self):
self.scatter.update(
marker={'colorbar': dict(bgcolor='yellow', thickness=5)})
assert isinstance(self.scatter['marker']['colorbar'],
go.scatter.marker.ColorBar)
d1, d2 = strip_dict_params(self.scatter['marker']['colorbar'],
self.expected_nested['marker']['colorbar'])
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_update_dict(self):
self.scatter.update(
marker={'colorbar': dict(bgcolor='yellow', thickness=5)})
assert isinstance(self.scatter['marker']['colorbar'],
go.scatter.marker.ColorBar)
d1, d2 = strip_dict_params(self.scatter['marker']['colorbar'],
self.expected_nested['marker']['colorbar'])
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_update_list(self):
trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2])
trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1])
fig = Figure([trace1, trace2])
update = dict(x=[2, 3, 4], y=[1, 2, 3])
update_res1 = fig.data[0].update(update)
update_res2 = fig.data[1].update(update)
d1, d2 = strip_dict_params(fig.data[0], Scatter(x=[2, 3, 4], y=[1, 2, 3]))
assert d1 == d2
d1, d2 = strip_dict_params(fig.data[1], Scatter(x=[2, 3, 4], y=[1, 2, 3]))
assert d1 == d2
assert update_res1 is fig.data[0]
assert update_res2 is fig.data[1]
def test_update_list(self):
trace1 = Scatter(x=[1, 2, 3], y=[2, 1, 2])
trace2 = Scatter(x=[1, 2, 3], y=[3, 2, 1])
fig = Figure([trace1, trace2])
update = dict(x=[2, 3, 4], y=[1, 2, 3])
update_res1 = fig.data[0].update(update)
update_res2 = fig.data[1].update(update)
d1, d2 = strip_dict_params(fig.data[0], Scatter(x=[2, 3, 4], y=[1, 2, 3]))
assert d1 == d2
d1, d2 = strip_dict_params(fig.data[1], Scatter(x=[2, 3, 4], y=[1, 2, 3]))
assert d1 == d2
assert update_res1 is fig.data[0]
assert update_res2 is fig.data[1]
def test_nested_dict_tuple(self):
d1, d2 = strip_dict_params(self.scatter[('marker', 'colorbar')], {})
assert d1 == d2
self.scatter[('marker', 'colorbar')] = dict(
bgcolor='yellow', thickness=5)
assert isinstance(self.scatter[('marker', 'colorbar')],
go.scatter.marker.ColorBar)
d1, d2 = strip_dict_params(self.scatter[('marker', 'colorbar')],
self.expected_nested['marker']['colorbar'])
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_obj(self):
d1, d2 = strip_dict_params(self.scatter.marker.colorbar, {})
assert d1 == d2
self.scatter.marker.colorbar = go.scatter.marker.ColorBar(
bgcolor='yellow', thickness=5)
assert isinstance(self.scatter.marker.colorbar,
go.scatter.marker.ColorBar)
d1, d2 = strip_dict_params(self.scatter.marker.colorbar,
self.expected_nested['marker']['colorbar'])
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_update_dict(self):
self.scatter.update(marker={"colorbar": dict(bgcolor="yellow", thickness=5)})
assert isinstance(
self.scatter["marker"]["colorbar"], go.scatter.marker.ColorBar
)
d1, d2 = strip_dict_params(
self.scatter["marker"]["colorbar"],
self.expected_nested["marker"]["colorbar"],
)
assert d1 == d2
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def setUp(self):
# Construct initial scatter object
self.parcoords = go.Parcoords(name='parcoords A')
# Assert initial state
d1, d2 = strip_dict_params(
self.parcoords,
{'type': 'parcoords',
'name': 'parcoords A'}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
'type': 'parcoords',
'name': 'parcoords A',
'dimensions': [
{'values': [2, 3, 1], 'visible': True},
{'values': [1, 2, 3], 'label': 'dim1'}]}
self.layout = go.Layout()
self.expected_layout1 = {
'updatemenus': [{},
{'font': {'family': 'courier'}}]
}
self.expected_layout2 = {
'updatemenus': [{},
{'buttons': [
{}, {}, {'method': 'restyle'}]}]
}
def setUp(self):
# Construct initial scatter object
self.scatter = go.Scatter(name='scatter A')
# Assert initial state
d1, d2 = strip_dict_params(
self.scatter,
{'type': 'scatter',
'name': 'scatter A'}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
'type': 'scatter',
'name': 'scatter A',
'fillcolor': 'green'}
self.expected_nested = {
'type': 'scatter',
'name': 'scatter A',
'marker': {'colorbar': {
'title': {'font': {'family': 'courier'}}}}}
self.expected_nested_error_x = {
'type': 'scatter',
'name': 'scatter A',
'error_x': {'type': 'percent'}}
def test_nested_update_dots(self):
assert self.scatter['marker.colorbar.title.font.family'] is None
self.scatter.update({'marker.colorbar.title.font.family': 'courier'})
assert self.scatter['marker.colorbar.title.font.family'] == 'courier'
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_h_and_v_bars():
fig, ax = plt.subplots()
ax.bar(
left=D["multi_left"],
height=D["multi_height"],
width=10,
color="green",
alpha=0.5,
)
# changing height 10 -> 14 because ValueError if bargap not in [0, 1]
ax.barh(
bottom=D["multi_bottom"],
width=D["multi_width"],
height=14,
color="red",
alpha=0.5,
)
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig["data"]):
d1, d2 = strip_dict_params(data_dict,
H_AND_V_BARS["data"][data_no],
ignore=["uid"])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig["layout"],
H_AND_V_BARS["layout"])
assert equivalent, msg
def test_nested_update_underscores(self):
assert self.scatter['error_x.type'] is None
self.scatter.update({'error_x_type': 'percent'})
assert self.scatter['error_x_type'] == 'percent'
d1, d2 = strip_dict_params(self.scatter, self.expected_nested_error_x)
assert d1 == d2
def test_nested_update_dots(self):
assert self.scatter['marker.colorbar.title.font.family'] is None
self.scatter.update({'marker.colorbar.title.font.family': 'courier'})
assert self.scatter['marker.colorbar.title.font.family'] == 'courier'
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def setUp(self):
# Construct initial scatter object
self.scatter = go.Scatter(name='scatter A')
# Assert initial state
d1, d2 = strip_dict_params(self.scatter, {
'type': 'scatter',
'name': 'scatter A'
})
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
'type': 'scatter',
'name': 'scatter A',
'fillcolor': 'green'
}
self.expected_nested = {
'type': 'scatter',
'name': 'scatter A',
'marker': {
'colorbar': {
'title': {
'font': {
'family': 'courier'
}
}
}
}
}
def test_complicated_line():
fig, ax = plt.subplots()
ax.plot(D["x1"], D["y1"], "ro", markersize=10, alpha=0.5, label="one")
ax.plot(D["x1"], D["y1"], "-b", linewidth=2, alpha=0.7, label="two")
ax.plot(
D["x2"],
D["y2"],
"b+",
markeredgewidth=2,
markersize=10,
alpha=0.6,
label="three",
)
ax.plot(D["x2"], D["y2"], "--r", linewidth=2, alpha=0.8, label="four")
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig["data"]):
d1, d2 = strip_dict_params(data_dict,
COMPLICATED_LINE["data"][data_no],
ignore=["uid"])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig["layout"],
COMPLICATED_LINE["layout"])
assert equivalent, msg
def test_toplevel_item(self):
assert self.scatter['fillcolor'] is None
self.scatter['fillcolor'] = 'green'
assert self.scatter['fillcolor'] == 'green'
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def test_h_and_v_bars():
fig, ax = plt.subplots()
ax.bar(left=D['multi_left'],
height=D['multi_height'],
width=10,
color='green',
alpha=.5)
# changing height 10 -> 14 because ValueError if bargap not in [0, 1]
ax.barh(bottom=D['multi_bottom'],
width=D['multi_width'],
height=14,
color='red',
alpha=.5)
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict,
H_AND_V_BARS['data'][data_no],
ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
H_AND_V_BARS['layout'])
assert equivalent, msg
def test_nested_update_underscores(self):
assert self.scatter['error_x.type'] is None
self.scatter.update({'error_x_type': 'percent'})
assert self.scatter['error_x_type'] == 'percent'
d1, d2 = strip_dict_params(self.scatter, self.expected_nested_error_x)
assert d1 == d2
def test_nested_item_tuple(self):
assert self.scatter['marker.colorbar.titlefont.family'] is None
self.scatter[('marker', 'colorbar', 'titlefont', 'family')] = 'courier'
assert (self.scatter[('marker', 'colorbar', 'titlefont', 'family')]
== 'courier')
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_toplevel_item(self):
assert self.scatter['fillcolor'] is None
self.scatter['fillcolor'] = 'green'
assert self.scatter['fillcolor'] == 'green'
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def test_nested_update_underscores(self):
assert self.scatter["error_x.type"] is None
self.scatter.update({"error_x_type": "percent"})
assert self.scatter["error_x_type"] == "percent"
d1, d2 = strip_dict_params(self.scatter, self.expected_nested_error_x)
assert d1 == d2
def setUp(self):
# Construct initial scatter object
self.scatter = go.Scatter(name='scatter A')
# Assert initial state
d1, d2 = strip_dict_params(
self.scatter,
{'type': 'scatter',
'name': 'scatter A'}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
'type': 'scatter',
'name': 'scatter A',
'marker': {'color': 'yellow',
'size': 10}}
self.expected_nested = {
'type': 'scatter',
'name': 'scatter A',
'marker': {'colorbar': {
'bgcolor': 'yellow',
'thickness': 5}}}
def setUp(self):
# Construct initial scatter object
self.parcoords = go.Parcoords(name='parcoords A')
# Assert initial state
d1, d2 = strip_dict_params(
self.parcoords,
{'type': 'parcoords',
'name': 'parcoords A'}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
'type': 'parcoords',
'name': 'parcoords A',
'dimensions': [
{'values': [2, 3, 1], 'visible': True},
{'values': [1, 2, 3], 'label': 'dim1'}]}
self.layout = go.Layout()
self.expected_layout1 = {
'updatemenus': [{},
{'font': {'family': 'courier'}}]
}
self.expected_layout2 = {
'updatemenus': [{},
{'buttons': [
{}, {}, {'method': 'restyle'}]}]
}
def test_toplevel_attr(self):
assert self.scatter.fillcolor is None
self.scatter.fillcolor = 'green'
assert self.scatter.fillcolor == 'green'
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def test_toplevel_attr(self):
assert self.scatter.fillcolor is None
self.scatter.fillcolor = "green"
assert self.scatter.fillcolor == "green"
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def setUp(self):
# Construct initial scatter object
self.parcoords = go.Parcoords(name="parcoords A")
# Assert initial state
d1, d2 = strip_dict_params(
self.parcoords, {"type": "parcoords", "name": "parcoords A"}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
"type": "parcoords",
"name": "parcoords A",
"dimensions": [
{"values": [2, 3, 1], "visible": True},
{"values": [1, 2, 3], "label": "dim1"},
],
}
self.layout = go.Layout()
self.expected_layout1 = {"updatemenus": [{}, {"font": {"family": "courier"}}]}
self.expected_layout2 = {
"updatemenus": [{}, {"buttons": [{}, {}, {"method": "restyle"}]}]
}
def setUp(self):
# Construct initial scatter object
self.scatter = go.Scatter(name="scatter A")
# Assert initial state
d1, d2 = strip_dict_params(
self.scatter, {"type": "scatter", "name": "scatter A"}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
"type": "scatter",
"name": "scatter A",
"fillcolor": "green",
}
self.expected_nested = {
"type": "scatter",
"name": "scatter A",
"marker": {"colorbar": {"title": {"font": {"family": "courier"}}}},
}
self.expected_nested_error_x = {
"type": "scatter",
"name": "scatter A",
"error_x": {"type": "percent"},
}
def test_toplevel_item(self):
assert self.scatter["fillcolor"] is None
self.scatter["fillcolor"] = "green"
assert self.scatter["fillcolor"] == "green"
d1, d2 = strip_dict_params(self.scatter, self.expected_toplevel)
assert d1 == d2
def test_nested_update_dots(self):
assert self.scatter["marker.colorbar.title.font.family"] is None
self.scatter.update({"marker.colorbar.title.font.family": "courier"})
assert self.scatter["marker.colorbar.title.font.family"] == "courier"
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def setUp(self):
# Construct initial scatter object
self.scatter = go.Scatter(name='scatter A')
# Assert initial state
d1, d2 = strip_dict_params(
self.scatter,
{'type': 'scatter',
'name': 'scatter A'}
)
assert d1 == d2
# Construct expected results
self.expected_toplevel = {
'type': 'scatter',
'name': 'scatter A',
'marker': {'color': 'yellow',
'size': 10}}
self.expected_nested = {
'type': 'scatter',
'name': 'scatter A',
'marker': {'colorbar': {
'bgcolor': 'yellow',
'thickness': 5}}}
def test_nested_update(self):
self.scatter.update(
marker={'colorbar': {'titlefont': {'family': 'courier'}}})
assert (self.scatter[('marker', 'colorbar', 'titlefont', 'family')]
== 'courier')
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_item_tuple(self):
assert self.scatter['marker.colorbar.title.font.family'] is None
self.scatter[('marker', 'colorbar', 'title.font', 'family')] = 'courier'
assert (self.scatter[('marker', 'colorbar', 'title.font', 'family')]
== 'courier')
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_update(self):
self.scatter.update(
marker={'colorbar': {'title': {'font': {'family': 'courier'}}}})
assert (self.scatter[('marker', 'colorbar', 'title', 'font', 'family')]
== 'courier')
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_item(self):
assert (self.scatter['marker']['colorbar']['titlefont']['family']
is None)
self.scatter['marker']['colorbar']['titlefont']['family'] = 'courier'
assert (self.scatter['marker']['colorbar']['titlefont']['family']
== 'courier')
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_item(self):
assert self.scatter["marker"]["colorbar"]["title"]["font"]["family"] is None
self.scatter["marker"]["colorbar"]["title"]["font"]["family"] = "courier"
assert (
self.scatter["marker"]["colorbar"]["title"]["font"]["family"] == "courier"
)
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_item(self):
assert (self.scatter['marker']['colorbar']['title']['font']['family']
is None)
self.scatter['marker']['colorbar']['title']['font']['family'] = \
'courier'
assert (self.scatter['marker']['colorbar']['title']['font']['family']
== 'courier')
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_nested_update(self):
self.scatter.update(
marker={"colorbar": {"title": {"font": {"family": "courier"}}}}
)
assert (
self.scatter[("marker", "colorbar", "title", "font", "family")] == "courier"
)
d1, d2 = strip_dict_params(self.scatter, self.expected_nested)
assert d1 == d2
def test_assign_nested_attr(self):
self.assertEqual(self.layout.updatemenus, ())
# Initialize empty updatemenus
self.layout.updatemenus = [{}, {}]
self.assertEqual(self.layout['updatemenus'],
(go.layout.Updatemenu(), go.layout.Updatemenu()))
self.layout.updatemenus[1].font.family = 'courier'
d1, d2 = strip_dict_params(self.layout, self.expected_layout1)
assert d1 == d2
def test_assign_nested_attr(self):
self.assertEqual(self.layout.updatemenus, ())
# Initialize empty updatemenus
self.layout.updatemenus = [{}, {}]
self.assertEqual(self.layout['updatemenus'],
(go.layout.Updatemenu(), go.layout.Updatemenu()))
self.layout.updatemenus[1].font.family = 'courier'
d1, d2 = strip_dict_params(self.layout, self.expected_layout1)
assert d1 == d2
def test_simple_line():
fig, ax = plt.subplots()
ax.plot(D['x1'], D['y1'], label='simple')
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, SIMPLE_LINE['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
SIMPLE_LINE['layout'])
assert equivalent, msg
def test_simple_line():
fig, ax = plt.subplots()
ax.plot(D['x1'], D['y1'], label='simple')
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, SIMPLE_LINE['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
SIMPLE_LINE['layout'])
assert equivalent, msg
def test_simple_line():
fig, ax = plt.subplots()
ax.plot(D["x1"], D["y1"], label="simple")
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig["data"]):
d1, d2 = strip_dict_params(
data_dict, SIMPLE_LINE["data"][data_no], ignore=["uid"]
)
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig["layout"], SIMPLE_LINE["layout"])
assert equivalent, msg
def test_simple_scatter():
fig, ax = plt.subplots()
ax.scatter(D['x1'], D['y1'])
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, SIMPLE_SCATTER['data'][data_no], ignore=['uid'])
print(d1)
print('\n')
print(d2)
assert d1 == d2
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
SIMPLE_SCATTER['layout'])
assert equivalent, msg
def test_vertical_bar():
fig, ax = plt.subplots()
ax.bar(left=D['left'], height=D['height'])
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, VERTICAL_BAR['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
VERTICAL_BAR['layout'])
assert equivalent, msg
def test_horizontal_bar():
fig, ax = plt.subplots()
ax.barh(bottom=D['bottom'], width=D['width'])
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, HORIZONTAL_BAR['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
HORIZONTAL_BAR['layout'])
assert equivalent, msg
def test_double_scatter():
fig, ax = plt.subplots()
ax.scatter(D['x1'], D['y1'], color='red', s=121, marker='^', alpha=0.5)
ax.scatter(D['x2'], D['y2'], color='purple', s=64, marker='s', alpha=0.5)
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, DOUBLE_SCATTER['data'][data_no], ignore=['uid'])
print(d1)
print('\n')
print(d2)
assert d1 == d2
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
DOUBLE_SCATTER['layout'])
assert equivalent, msg
def test_complicated_line():
fig, ax = plt.subplots()
ax.plot(D['x1'], D['y1'], 'ro', markersize=10, alpha=.5, label='one')
ax.plot(D['x1'], D['y1'], '-b', linewidth=2, alpha=.7, label='two')
ax.plot(D['x2'], D['y2'], 'b+', markeredgewidth=2,
markersize=10, alpha=.6, label='three')
ax.plot(D['x2'], D['y2'], '--r', linewidth=2, alpha=.8, label='four')
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, COMPLICATED_LINE['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
COMPLICATED_LINE['layout'])
assert equivalent, msg
def test_h_and_v_bars():
fig, ax = plt.subplots()
ax.bar(left=D['multi_left'], height=D['multi_height'],
width=10, color='green', alpha=.5)
# changing height 10 -> 14 because ValueError if bargap not in [0, 1]
ax.barh(bottom=D['multi_bottom'], width=D['multi_width'],
height=14, color='red', alpha=.5)
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, H_AND_V_BARS['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
H_AND_V_BARS['layout'])
assert equivalent, msg
def test_update_double_nested_underscore(self):
self.assertEqual(self.layout.updatemenus, ())
# Initialize empty updatemenus
self.layout['updatemenus'] = [{}, {}]
# Initialize empty buttons in updatemenu[1]
self.layout['updatemenus_1_buttons'] = [{}, {}, {}]
# Update
self.layout.update({'updatemenus_1_buttons_2_method': 'restyle'})
# Check
self.assertEqual(
self.layout['updatemenus[1].buttons[2].method'],
'restyle')
d1, d2 = strip_dict_params(self.layout, self.expected_layout2)
assert d1 == d2
def test_assign_double_nested_dot(self):
self.assertEqual(self.layout.updatemenus, ())
# Initialize empty updatemenus
self.layout['updatemenus'] = [{}, {}]
# Initialize empty buttons in updatemenu[1]
self.layout['updatemenus.1.buttons'] = [{}, {}, {}]
# Assign
self.layout['updatemenus[1].buttons[2].method'] = 'restyle'
# Check
self.assertEqual(
self.layout['updatemenus[1].buttons[2].method'],
'restyle')
d1, d2 = strip_dict_params(self.layout, self.expected_layout2)
assert d1 == d2
def test_assign_double_nested_update_array(self):
# Initialize empty updatemenus
self.layout.updatemenus = [{}, {}]
# Initialize empty buttons in updatemenu[1]
self.layout.updatemenus[1].buttons = [{}, {}, {}]
# Update
self.layout.update(
updatemenus=[{}, {'buttons': [{}, {}, {'method': 'restyle'}]}])
# Check
self.assertEqual(
self.layout.updatemenus[1].buttons[2].method,
'restyle')
d1, d2 = strip_dict_params(self.layout, self.expected_layout2)
assert d1 == d2
def test_assign_double_nested_tuple(self):
self.assertEqual(self.layout.updatemenus, ())
# Initialize empty updatemenus
self.layout.updatemenus = [{}, {}]
# Initialize empty buttons in updatemenu[1]
self.layout[('updatemenus', 1, 'buttons')] = [{}, {}, {}]
# Assign
self.layout[('updatemenus', 1, 'buttons', 2, 'method')] = 'restyle'
# Check
self.assertEqual(
self.layout[('updatemenus', 1, 'buttons', 2, 'method')],
'restyle')
d1, d2 = strip_dict_params(self.layout, self.expected_layout2)
assert d1 == d2
def test_even_linear_scale():
fig, ax = plt.subplots()
x = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10]
y = [10, 3, 100, 6, 45, 4, 80, 45, 3, 59]
ax.plot(x, y)
_ = ax.set_xticks(list(range(0, 20, 3)), True)
_ = ax.set_yticks(list(range(0, 200, 13)), True)
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
# equivalent, msg = compare_dict(data_dict.to_plotly_json(),
# EVEN_LINEAR_SCALE['data'][data_no].to_plotly_json())
# assert equivalent, msg
d1, d2 = strip_dict_params(data_dict, EVEN_LINEAR_SCALE['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
equivalent, msg = compare_dict(renderer.plotly_fig['layout'],
EVEN_LINEAR_SCALE['layout'])
assert equivalent, msg
def test_annotations():
fig, ax = plt.subplots()
ax.plot([1, 2, 3], 'b-')
ax.plot([3, 2, 1], 'b-')
ax.text(0.001, 0.999,
'top-left', transform=ax.transAxes, va='top', ha='left')
ax.text(0.001, 0.001,
'bottom-left', transform=ax.transAxes, va='baseline', ha='left')
ax.text(0.999, 0.999,
'top-right', transform=ax.transAxes, va='top', ha='right')
ax.text(0.999, 0.001,
'bottom-right', transform=ax.transAxes, va='baseline', ha='right')
renderer = run_fig(fig)
for data_no, data_dict in enumerate(renderer.plotly_fig['data']):
d1, d2 = strip_dict_params(data_dict, ANNOTATIONS['data'][data_no], ignore=['uid'])
equivalent, msg = compare_dict(d1, d2)
assert equivalent, msg
for no, note in enumerate(renderer.plotly_fig['layout']['annotations']):
equivalent, msg = compare_dict(note,
ANNOTATIONS['layout']['annotations'][no])
assert equivalent, msg