Created
October 22, 2021 07:31
-
-
Save tomron/37b33223b73159aea4783c49ac80f5d4 to your computer and use it in GitHub Desktop.
Other pie - creat a pie chart with the top `n-1` values as separate sectors and other sector for the remaining values
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| """ | |
| `plotly.express` is a terse, consistent, high-level wrapper around `plotly.graph_objects` | |
| for rapid data exploration and figure generation. Learn more at https://plotly.express/ | |
| """ | |
| from __future__ import absolute_import | |
| from plotly import optional_imports | |
| pd = optional_imports.get_module("pandas") | |
| if pd is None: | |
| raise ImportError( | |
| """\ | |
| Plotly express requires pandas to be installed.""" | |
| ) | |
| from ._imshow import imshow | |
| from ._chart_types import ( # noqa: F401 | |
| scatter, | |
| scatter_3d, | |
| scatter_polar, | |
| scatter_ternary, | |
| scatter_mapbox, | |
| scatter_geo, | |
| line, | |
| line_3d, | |
| line_polar, | |
| line_ternary, | |
| line_mapbox, | |
| line_geo, | |
| area, | |
| bar, | |
| timeline, | |
| bar_polar, | |
| violin, | |
| box, | |
| strip, | |
| histogram, | |
| ecdf, | |
| scatter_matrix, | |
| parallel_coordinates, | |
| parallel_categories, | |
| choropleth, | |
| density_contour, | |
| density_heatmap, | |
| pie, | |
| other_pie, | |
| sunburst, | |
| treemap, | |
| icicle, | |
| funnel, | |
| funnel_area, | |
| choropleth_mapbox, | |
| density_mapbox, | |
| ) | |
| from ._core import ( # noqa: F401 | |
| set_mapbox_access_token, | |
| defaults, | |
| get_trendline_results, | |
| NO_COLOR, | |
| ) | |
| from ._special_inputs import IdentityMap, Constant, Range # noqa: F401 | |
| from . import data, colors, trendline_functions # noqa: F401 | |
| __all__ = [ | |
| "scatter", | |
| "scatter_3d", | |
| "scatter_polar", | |
| "scatter_ternary", | |
| "scatter_mapbox", | |
| "scatter_geo", | |
| "scatter_matrix", | |
| "density_contour", | |
| "density_heatmap", | |
| "density_mapbox", | |
| "line", | |
| "line_3d", | |
| "line_polar", | |
| "line_ternary", | |
| "line_mapbox", | |
| "line_geo", | |
| "parallel_coordinates", | |
| "parallel_categories", | |
| "area", | |
| "bar", | |
| "timeline", | |
| "bar_polar", | |
| "violin", | |
| "box", | |
| "strip", | |
| "histogram", | |
| "ecdf", | |
| "choropleth", | |
| "choropleth_mapbox", | |
| "pie", | |
| "other_pie", | |
| "sunburst", | |
| "treemap", | |
| "icicle", | |
| "funnel", | |
| "funnel_area", | |
| "imshow", | |
| "data", | |
| "colors", | |
| "trendline_functions", | |
| "set_mapbox_access_token", | |
| "get_trendline_results", | |
| "IdentityMap", | |
| "Constant", | |
| "Range", | |
| "NO_COLOR", | |
| ] |
This file contains bidirectional Unicode text that may be interpreted or compiled differently than what appears below. To review, open the file in an editor that reveals hidden Unicode characters.
Learn more about bidirectional Unicode characters
| from ._core import make_figure | |
| from ._doc import make_docstring | |
| import plotly.graph_objs as go | |
| _wide_mode_xy_append = [ | |
| "Either `x` or `y` can optionally be a list of column references or array_likes, ", | |
| "in which case the data will be treated as if it were 'wide' rather than 'long'.", | |
| ] | |
| _cartesian_append_dict = dict(x=_wide_mode_xy_append, y=_wide_mode_xy_append) | |
| def scatter( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| symbol=None, | |
| size=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| error_x=None, | |
| error_x_minus=None, | |
| error_y=None, | |
| error_y_minus=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| orientation=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| opacity=None, | |
| size_max=None, | |
| marginal_x=None, | |
| marginal_y=None, | |
| trendline=None, | |
| trendline_options=None, | |
| trendline_color_override=None, | |
| trendline_scope="trace", | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| render_mode="auto", | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a scatter plot, each row of `data_frame` is represented by a symbol | |
| mark in 2D space. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatter) | |
| scatter.__doc__ = make_docstring(scatter, append_dict=_cartesian_append_dict) | |
| def density_contour( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| z=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| orientation=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| marginal_x=None, | |
| marginal_y=None, | |
| trendline=None, | |
| trendline_options=None, | |
| trendline_color_override=None, | |
| trendline_scope="trace", | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| histfunc=None, | |
| histnorm=None, | |
| nbinsx=None, | |
| nbinsy=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a density contour plot, rows of `data_frame` are grouped together | |
| into contour marks to visualize the 2D distribution of an aggregate | |
| function `histfunc` (e.g. the count or sum) of the value `z`. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Histogram2dContour, | |
| trace_patch=dict( | |
| contours=dict(coloring="none"), | |
| histfunc=histfunc, | |
| histnorm=histnorm, | |
| nbinsx=nbinsx, | |
| nbinsy=nbinsy, | |
| xbingroup="x", | |
| ybingroup="y", | |
| ), | |
| ) | |
| density_contour.__doc__ = make_docstring( | |
| density_contour, | |
| append_dict=dict( | |
| x=_wide_mode_xy_append, | |
| y=_wide_mode_xy_append, | |
| z=[ | |
| "For `density_heatmap` and `density_contour` these values are used as the inputs to `histfunc`.", | |
| ], | |
| histfunc=["The arguments to this function are the values of `z`."], | |
| ), | |
| ) | |
| def density_heatmap( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| z=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| orientation=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| marginal_x=None, | |
| marginal_y=None, | |
| opacity=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| histfunc=None, | |
| histnorm=None, | |
| nbinsx=None, | |
| nbinsy=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a density heatmap, rows of `data_frame` are grouped together into | |
| colored rectangular tiles to visualize the 2D distribution of an | |
| aggregate function `histfunc` (e.g. the count or sum) of the value `z`. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Histogram2d, | |
| trace_patch=dict( | |
| histfunc=histfunc, | |
| histnorm=histnorm, | |
| nbinsx=nbinsx, | |
| nbinsy=nbinsy, | |
| xbingroup="x", | |
| ybingroup="y", | |
| ), | |
| ) | |
| density_heatmap.__doc__ = make_docstring( | |
| density_heatmap, | |
| append_dict=dict( | |
| x=_wide_mode_xy_append, | |
| y=_wide_mode_xy_append, | |
| z=[ | |
| "For `density_heatmap` and `density_contour` these values are used as the inputs to `histfunc`.", | |
| ], | |
| histfunc=["The arguments to this function are the values of `z`.",], | |
| ), | |
| ) | |
| def line( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| line_group=None, | |
| color=None, | |
| line_dash=None, | |
| symbol=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| error_x=None, | |
| error_x_minus=None, | |
| error_y=None, | |
| error_y_minus=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| orientation=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| line_dash_sequence=None, | |
| line_dash_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| markers=False, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| line_shape=None, | |
| render_mode="auto", | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a 2D line plot, each row of `data_frame` is represented as vertex of | |
| a polyline mark in 2D space. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatter) | |
| line.__doc__ = make_docstring(line, append_dict=_cartesian_append_dict) | |
| def area( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| line_group=None, | |
| color=None, | |
| symbol=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| markers=False, | |
| orientation=None, | |
| groupnorm=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| line_shape=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a stacked area plot, each row of `data_frame` is represented as | |
| vertex of a polyline mark in 2D space. The area between successive | |
| polylines is filled. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Scatter, | |
| trace_patch=dict(stackgroup=1, mode="lines", groupnorm=groupnorm), | |
| ) | |
| area.__doc__ = make_docstring(area, append_dict=_cartesian_append_dict) | |
| def bar( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| pattern_shape=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| base=None, | |
| error_x=None, | |
| error_x_minus=None, | |
| error_y=None, | |
| error_y_minus=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| pattern_shape_sequence=None, | |
| pattern_shape_map=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| opacity=None, | |
| orientation=None, | |
| barmode="relative", | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a bar plot, each row of `data_frame` is represented as a rectangular | |
| mark. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Bar, | |
| trace_patch=dict(textposition="auto"), | |
| layout_patch=dict(barmode=barmode), | |
| ) | |
| bar.__doc__ = make_docstring(bar, append_dict=_cartesian_append_dict) | |
| def timeline( | |
| data_frame=None, | |
| x_start=None, | |
| x_end=None, | |
| y=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| opacity=None, | |
| range_x=None, | |
| range_y=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a timeline plot, each row of `data_frame` is represented as a rectangular | |
| mark on an x axis of type `date`, spanning from `x_start` to `x_end`. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor="timeline", | |
| trace_patch=dict(textposition="auto", orientation="h"), | |
| layout_patch=dict(barmode="overlay"), | |
| ) | |
| timeline.__doc__ = make_docstring(timeline) | |
| def histogram( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| pattern_shape=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| pattern_shape_sequence=None, | |
| pattern_shape_map=None, | |
| marginal=None, | |
| opacity=None, | |
| orientation=None, | |
| barmode="relative", | |
| barnorm=None, | |
| histnorm=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| histfunc=None, | |
| cumulative=None, | |
| nbins=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a histogram, rows of `data_frame` are grouped together into a | |
| rectangular mark to visualize the 1D distribution of an aggregate | |
| function `histfunc` (e.g. the count or sum) of the value `y` (or `x` if | |
| `orientation` is `'h'`). | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Histogram, | |
| trace_patch=dict( | |
| histnorm=histnorm, histfunc=histfunc, cumulative=dict(enabled=cumulative), | |
| ), | |
| layout_patch=dict(barmode=barmode, barnorm=barnorm), | |
| ) | |
| histogram.__doc__ = make_docstring( | |
| histogram, | |
| append_dict=dict( | |
| x=["If `orientation` is `'h'`, these values are used as inputs to `histfunc`."] | |
| + _wide_mode_xy_append, | |
| y=["If `orientation` is `'v'`, these values are used as inputs to `histfunc`."] | |
| + _wide_mode_xy_append, | |
| histfunc=[ | |
| "The arguments to this function are the values of `y`(`x`) if `orientation` is `'v'`(`'h'`).", | |
| ], | |
| ), | |
| ) | |
| def ecdf( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| text=None, | |
| line_dash=None, | |
| symbol=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| markers=False, | |
| lines=True, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| line_dash_sequence=None, | |
| line_dash_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| marginal=None, | |
| opacity=None, | |
| orientation=None, | |
| ecdfnorm="probability", | |
| ecdfmode="standard", | |
| render_mode="auto", | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a Empirical Cumulative Distribution Function (ECDF) plot, rows of `data_frame` | |
| are sorted by the value `x` (or `y` if `orientation` is `'h'`) and their cumulative | |
| count (or the cumulative sum of `y` if supplied and `orientation` is `h`) is drawn | |
| as a line. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatter) | |
| ecdf.__doc__ = make_docstring( | |
| ecdf, | |
| append_dict=dict( | |
| x=[ | |
| "If `orientation` is `'h'`, the cumulative sum of this argument is plotted rather than the cumulative count." | |
| ] | |
| + _wide_mode_xy_append, | |
| y=[ | |
| "If `orientation` is `'v'`, the cumulative sum of this argument is plotted rather than the cumulative count." | |
| ] | |
| + _wide_mode_xy_append, | |
| ), | |
| ) | |
| def violin( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| orientation=None, | |
| violinmode=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| points=None, | |
| box=False, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a violin plot, rows of `data_frame` are grouped together into a | |
| curved mark to visualize their distribution. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Violin, | |
| trace_patch=dict( | |
| points=points, box=dict(visible=box), scalegroup=True, x0=" ", y0=" ", | |
| ), | |
| layout_patch=dict(violinmode=violinmode), | |
| ) | |
| violin.__doc__ = make_docstring(violin, append_dict=_cartesian_append_dict) | |
| def box( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| orientation=None, | |
| boxmode=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| points=None, | |
| notched=False, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a box plot, rows of `data_frame` are grouped together into a | |
| box-and-whisker mark to visualize their distribution. | |
| Each box spans from quartile 1 (Q1) to quartile 3 (Q3). The second | |
| quartile (Q2) is marked by a line inside the box. By default, the | |
| whiskers correspond to the box' edges +/- 1.5 times the interquartile | |
| range (IQR: Q3-Q1), see "points" for other options. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Box, | |
| trace_patch=dict(boxpoints=points, notched=notched, x0=" ", y0=" "), | |
| layout_patch=dict(boxmode=boxmode), | |
| ) | |
| box.__doc__ = make_docstring(box, append_dict=_cartesian_append_dict) | |
| def strip( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| orientation=None, | |
| stripmode=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a strip plot each row of `data_frame` is represented as a jittered | |
| mark within categories. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Box, | |
| trace_patch=dict( | |
| boxpoints="all", | |
| pointpos=0, | |
| hoveron="points", | |
| fillcolor="rgba(255,255,255,0)", | |
| line={"color": "rgba(255,255,255,0)"}, | |
| x0=" ", | |
| y0=" ", | |
| ), | |
| layout_patch=dict(boxmode=stripmode), | |
| ) | |
| strip.__doc__ = make_docstring(strip, append_dict=_cartesian_append_dict) | |
| def scatter_3d( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| z=None, | |
| color=None, | |
| symbol=None, | |
| size=None, | |
| text=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| error_x=None, | |
| error_x_minus=None, | |
| error_y=None, | |
| error_y_minus=None, | |
| error_z=None, | |
| error_z_minus=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| size_max=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| opacity=None, | |
| log_x=False, | |
| log_y=False, | |
| log_z=False, | |
| range_x=None, | |
| range_y=None, | |
| range_z=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a 3D scatter plot, each row of `data_frame` is represented by a | |
| symbol mark in 3D space. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatter3d) | |
| scatter_3d.__doc__ = make_docstring(scatter_3d) | |
| def line_3d( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| z=None, | |
| color=None, | |
| line_dash=None, | |
| text=None, | |
| line_group=None, | |
| symbol=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| error_x=None, | |
| error_x_minus=None, | |
| error_y=None, | |
| error_y_minus=None, | |
| error_z=None, | |
| error_z_minus=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| line_dash_sequence=None, | |
| line_dash_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| markers=False, | |
| log_x=False, | |
| log_y=False, | |
| log_z=False, | |
| range_x=None, | |
| range_y=None, | |
| range_z=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a 3D line plot, each row of `data_frame` is represented as vertex of | |
| a polyline mark in 3D space. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatter3d) | |
| line_3d.__doc__ = make_docstring(line_3d) | |
| def scatter_ternary( | |
| data_frame=None, | |
| a=None, | |
| b=None, | |
| c=None, | |
| color=None, | |
| symbol=None, | |
| size=None, | |
| text=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| opacity=None, | |
| size_max=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a ternary scatter plot, each row of `data_frame` is represented by a | |
| symbol mark in ternary coordinates. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatterternary) | |
| scatter_ternary.__doc__ = make_docstring(scatter_ternary) | |
| def line_ternary( | |
| data_frame=None, | |
| a=None, | |
| b=None, | |
| c=None, | |
| color=None, | |
| line_dash=None, | |
| line_group=None, | |
| symbol=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| line_dash_sequence=None, | |
| line_dash_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| markers=False, | |
| line_shape=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a ternary line plot, each row of `data_frame` is represented as | |
| vertex of a polyline mark in ternary coordinates. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatterternary) | |
| line_ternary.__doc__ = make_docstring(line_ternary) | |
| def scatter_polar( | |
| data_frame=None, | |
| r=None, | |
| theta=None, | |
| color=None, | |
| symbol=None, | |
| size=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| opacity=None, | |
| direction="clockwise", | |
| start_angle=90, | |
| size_max=None, | |
| range_r=None, | |
| range_theta=None, | |
| log_r=False, | |
| render_mode="auto", | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a polar scatter plot, each row of `data_frame` is represented by a | |
| symbol mark in polar coordinates. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatterpolar) | |
| scatter_polar.__doc__ = make_docstring(scatter_polar) | |
| def line_polar( | |
| data_frame=None, | |
| r=None, | |
| theta=None, | |
| color=None, | |
| line_dash=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| line_group=None, | |
| text=None, | |
| symbol=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| line_dash_sequence=None, | |
| line_dash_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| markers=False, | |
| direction="clockwise", | |
| start_angle=90, | |
| line_close=False, | |
| line_shape=None, | |
| render_mode="auto", | |
| range_r=None, | |
| range_theta=None, | |
| log_r=False, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a polar line plot, each row of `data_frame` is represented as vertex | |
| of a polyline mark in polar coordinates. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scatterpolar) | |
| line_polar.__doc__ = make_docstring(line_polar) | |
| def bar_polar( | |
| data_frame=None, | |
| r=None, | |
| theta=None, | |
| color=None, | |
| pattern_shape=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| base=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| pattern_shape_sequence=None, | |
| pattern_shape_map=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| barnorm=None, | |
| barmode="relative", | |
| direction="clockwise", | |
| start_angle=90, | |
| range_r=None, | |
| range_theta=None, | |
| log_r=False, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a polar bar plot, each row of `data_frame` is represented as a wedge | |
| mark in polar coordinates. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Barpolar, | |
| layout_patch=dict(barnorm=barnorm, barmode=barmode), | |
| ) | |
| bar_polar.__doc__ = make_docstring(bar_polar) | |
| def choropleth( | |
| data_frame=None, | |
| lat=None, | |
| lon=None, | |
| locations=None, | |
| locationmode=None, | |
| geojson=None, | |
| featureidkey=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| projection=None, | |
| scope=None, | |
| center=None, | |
| fitbounds=None, | |
| basemap_visible=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a choropleth map, each row of `data_frame` is represented by a | |
| colored region mark on a map. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Choropleth, | |
| trace_patch=dict(locationmode=locationmode), | |
| ) | |
| choropleth.__doc__ = make_docstring(choropleth) | |
| def scatter_geo( | |
| data_frame=None, | |
| lat=None, | |
| lon=None, | |
| locations=None, | |
| locationmode=None, | |
| geojson=None, | |
| featureidkey=None, | |
| color=None, | |
| text=None, | |
| symbol=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| size=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| opacity=None, | |
| size_max=None, | |
| projection=None, | |
| scope=None, | |
| center=None, | |
| fitbounds=None, | |
| basemap_visible=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a geographic scatter plot, each row of `data_frame` is represented | |
| by a symbol mark on a map. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Scattergeo, | |
| trace_patch=dict(locationmode=locationmode), | |
| ) | |
| scatter_geo.__doc__ = make_docstring(scatter_geo) | |
| def line_geo( | |
| data_frame=None, | |
| lat=None, | |
| lon=None, | |
| locations=None, | |
| locationmode=None, | |
| geojson=None, | |
| featureidkey=None, | |
| color=None, | |
| line_dash=None, | |
| text=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| line_group=None, | |
| symbol=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| line_dash_sequence=None, | |
| line_dash_map=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| markers=False, | |
| projection=None, | |
| scope=None, | |
| center=None, | |
| fitbounds=None, | |
| basemap_visible=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a geographic line plot, each row of `data_frame` is represented as | |
| vertex of a polyline mark on a map. | |
| """ | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Scattergeo, | |
| trace_patch=dict(locationmode=locationmode), | |
| ) | |
| line_geo.__doc__ = make_docstring(line_geo) | |
| def scatter_mapbox( | |
| data_frame=None, | |
| lat=None, | |
| lon=None, | |
| color=None, | |
| text=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| size=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| opacity=None, | |
| size_max=None, | |
| zoom=8, | |
| center=None, | |
| mapbox_style=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a Mapbox scatter plot, each row of `data_frame` is represented by a | |
| symbol mark on a Mapbox map. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scattermapbox) | |
| scatter_mapbox.__doc__ = make_docstring(scatter_mapbox) | |
| def choropleth_mapbox( | |
| data_frame=None, | |
| geojson=None, | |
| featureidkey=None, | |
| locations=None, | |
| color=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| opacity=None, | |
| zoom=8, | |
| center=None, | |
| mapbox_style=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a Mapbox choropleth map, each row of `data_frame` is represented by a | |
| colored region on a Mapbox map. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Choroplethmapbox) | |
| choropleth_mapbox.__doc__ = make_docstring(choropleth_mapbox) | |
| def density_mapbox( | |
| data_frame=None, | |
| lat=None, | |
| lon=None, | |
| z=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| opacity=None, | |
| zoom=8, | |
| center=None, | |
| mapbox_style=None, | |
| radius=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a Mapbox density map, each row of `data_frame` contributes to the intensity of | |
| the color of the region around the corresponding point on the map | |
| """ | |
| return make_figure( | |
| args=locals(), constructor=go.Densitymapbox, trace_patch=dict(radius=radius) | |
| ) | |
| density_mapbox.__doc__ = make_docstring(density_mapbox) | |
| def line_mapbox( | |
| data_frame=None, | |
| lat=None, | |
| lon=None, | |
| color=None, | |
| text=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| line_group=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| zoom=8, | |
| center=None, | |
| mapbox_style=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a Mapbox line plot, each row of `data_frame` is represented as | |
| vertex of a polyline mark on a Mapbox map. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Scattermapbox) | |
| line_mapbox.__doc__ = make_docstring(line_mapbox) | |
| def scatter_matrix( | |
| data_frame=None, | |
| dimensions=None, | |
| color=None, | |
| symbol=None, | |
| size=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| symbol_sequence=None, | |
| symbol_map=None, | |
| opacity=None, | |
| size_max=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a scatter plot matrix (or SPLOM), each row of `data_frame` is | |
| represented by a multiple symbol marks, one in each cell of a grid of | |
| 2D scatter plots, which plot each pair of `dimensions` against each | |
| other. | |
| """ | |
| return make_figure( | |
| args=locals(), constructor=go.Splom, layout_patch=dict(dragmode="select") | |
| ) | |
| scatter_matrix.__doc__ = make_docstring(scatter_matrix) | |
| def parallel_coordinates( | |
| data_frame=None, | |
| dimensions=None, | |
| color=None, | |
| labels=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a parallel coordinates plot, each row of `data_frame` is represented | |
| by a polyline mark which traverses a set of parallel axes, one for each | |
| of the `dimensions`. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Parcoords) | |
| parallel_coordinates.__doc__ = make_docstring(parallel_coordinates) | |
| def parallel_categories( | |
| data_frame=None, | |
| dimensions=None, | |
| color=None, | |
| labels=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| dimensions_max_cardinality=50, | |
| ): | |
| """ | |
| In a parallel categories (or parallel sets) plot, each row of | |
| `data_frame` is grouped with other rows that share the same values of | |
| `dimensions` and then plotted as a polyline mark through a set of | |
| parallel axes, one for each of the `dimensions`. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Parcats) | |
| parallel_categories.__doc__ = make_docstring(parallel_categories) | |
| def pie( | |
| data_frame=None, | |
| names=None, | |
| values=None, | |
| color=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| labels=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| opacity=None, | |
| hole=None, | |
| ): | |
| """ | |
| In a pie plot, each row of `data_frame` is represented as a sector of a | |
| pie. | |
| """ | |
| if color_discrete_sequence is not None: | |
| layout_patch = {"piecolorway": color_discrete_sequence} | |
| else: | |
| layout_patch = {} | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Pie, | |
| trace_patch=dict(showlegend=(names is not None), hole=hole), | |
| layout_patch=layout_patch, | |
| ) | |
| pie.__doc__ = make_docstring( | |
| pie, | |
| override_dict=dict( | |
| hole=[ | |
| "float", | |
| "Sets the fraction of the radius to cut out of the pie." | |
| "Use this to make a donut chart.", | |
| ], | |
| ), | |
| ) | |
| def other_pie( | |
| data_frame=None, | |
| names=None, | |
| values=None, | |
| color=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| labels=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| opacity=None, | |
| hole=None, | |
| n=None, | |
| other_label=None | |
| ): | |
| """ | |
| In a other pie plot, if `n` is None less than 1 each row of `data_frame` represented as a sector of a | |
| pie. Otherwise the `n-1` with the heighest valuess top `n-1` are represented as a sector of a pie and | |
| additional sector with label `other_label` of size sum of values in all other rows represents that | |
| remaining rows. | |
| """ | |
| if color_discrete_sequence is not None: | |
| layout_patch = {"piecolorway": color_discrete_sequence} | |
| else: | |
| layout_patch = {} | |
| if isinstance(n, int) and n > 1 and len(data_frame) > n: | |
| data_frame = data_frame.sort_values(values, ascending=False)[[names, values]] | |
| head_data_frame = data_frame.head(n-1) | |
| tail_value = data_frame.tail(len(data_frame)-(n-1))[values].sum() | |
| data_frame = head_data_frame.append({names: other_label, values: tail_value}, ignore_index=True) | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Pie, | |
| trace_patch=dict(showlegend=(names is not None), hole=hole), | |
| layout_patch=layout_patch, | |
| ) | |
| def sunburst( | |
| data_frame=None, | |
| names=None, | |
| values=None, | |
| parents=None, | |
| path=None, | |
| ids=None, | |
| color=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| labels=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| branchvalues=None, | |
| maxdepth=None, | |
| ): | |
| """ | |
| A sunburst plot represents hierarchial data as sectors laid out over | |
| several levels of concentric rings. | |
| """ | |
| if color_discrete_sequence is not None: | |
| layout_patch = {"sunburstcolorway": color_discrete_sequence} | |
| else: | |
| layout_patch = {} | |
| if path is not None and (ids is not None or parents is not None): | |
| raise ValueError( | |
| "Either `path` should be provided, or `ids` and `parents`." | |
| "These parameters are mutually exclusive and cannot be passed together." | |
| ) | |
| if path is not None and branchvalues is None: | |
| branchvalues = "total" | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Sunburst, | |
| trace_patch=dict(branchvalues=branchvalues, maxdepth=maxdepth), | |
| layout_patch=layout_patch, | |
| ) | |
| sunburst.__doc__ = make_docstring(sunburst) | |
| def treemap( | |
| data_frame=None, | |
| names=None, | |
| values=None, | |
| parents=None, | |
| ids=None, | |
| path=None, | |
| color=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| labels=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| branchvalues=None, | |
| maxdepth=None, | |
| ): | |
| """ | |
| A treemap plot represents hierarchial data as nested rectangular | |
| sectors. | |
| """ | |
| if color_discrete_sequence is not None: | |
| layout_patch = {"treemapcolorway": color_discrete_sequence} | |
| else: | |
| layout_patch = {} | |
| if path is not None and (ids is not None or parents is not None): | |
| raise ValueError( | |
| "Either `path` should be provided, or `ids` and `parents`." | |
| "These parameters are mutually exclusive and cannot be passed together." | |
| ) | |
| if path is not None and branchvalues is None: | |
| branchvalues = "total" | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Treemap, | |
| trace_patch=dict(branchvalues=branchvalues, maxdepth=maxdepth), | |
| layout_patch=layout_patch, | |
| ) | |
| treemap.__doc__ = make_docstring(treemap) | |
| def icicle( | |
| data_frame=None, | |
| names=None, | |
| values=None, | |
| parents=None, | |
| path=None, | |
| ids=None, | |
| color=None, | |
| color_continuous_scale=None, | |
| range_color=None, | |
| color_continuous_midpoint=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| labels=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| branchvalues=None, | |
| maxdepth=None, | |
| ): | |
| """ | |
| An icicle plot represents hierarchial data with adjoined rectangular | |
| sectors that all cascade from root down to leaf in one direction. | |
| """ | |
| if color_discrete_sequence is not None: | |
| layout_patch = {"iciclecolorway": color_discrete_sequence} | |
| else: | |
| layout_patch = {} | |
| if path is not None and (ids is not None or parents is not None): | |
| raise ValueError( | |
| "Either `path` should be provided, or `ids` and `parents`." | |
| "These parameters are mutually exclusive and cannot be passed together." | |
| ) | |
| if path is not None and branchvalues is None: | |
| branchvalues = "total" | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Icicle, | |
| trace_patch=dict(branchvalues=branchvalues, maxdepth=maxdepth), | |
| layout_patch=layout_patch, | |
| ) | |
| icicle.__doc__ = make_docstring(icicle) | |
| def funnel( | |
| data_frame=None, | |
| x=None, | |
| y=None, | |
| color=None, | |
| facet_row=None, | |
| facet_col=None, | |
| facet_col_wrap=0, | |
| facet_row_spacing=None, | |
| facet_col_spacing=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| text=None, | |
| animation_frame=None, | |
| animation_group=None, | |
| category_orders=None, | |
| labels=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| opacity=None, | |
| orientation=None, | |
| log_x=False, | |
| log_y=False, | |
| range_x=None, | |
| range_y=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| ): | |
| """ | |
| In a funnel plot, each row of `data_frame` is represented as a | |
| rectangular sector of a funnel. | |
| """ | |
| return make_figure(args=locals(), constructor=go.Funnel) | |
| funnel.__doc__ = make_docstring(funnel, append_dict=_cartesian_append_dict) | |
| def funnel_area( | |
| data_frame=None, | |
| names=None, | |
| values=None, | |
| color=None, | |
| color_discrete_sequence=None, | |
| color_discrete_map=None, | |
| hover_name=None, | |
| hover_data=None, | |
| custom_data=None, | |
| labels=None, | |
| title=None, | |
| template=None, | |
| width=None, | |
| height=None, | |
| opacity=None, | |
| ): | |
| """ | |
| In a funnel area plot, each row of `data_frame` is represented as a | |
| trapezoidal sector of a funnel. | |
| """ | |
| if color_discrete_sequence is not None: | |
| layout_patch = {"funnelareacolorway": color_discrete_sequence} | |
| else: | |
| layout_patch = {} | |
| return make_figure( | |
| args=locals(), | |
| constructor=go.Funnelarea, | |
| trace_patch=dict(showlegend=(names is not None)), | |
| layout_patch=layout_patch, | |
| ) | |
| funnel_area.__doc__ = make_docstring(funnel_area) |
Sign up for free
to join this conversation on GitHub.
Already have an account?
Sign in to comment