g5tUdZddlmZddlZddlZddlZddlmZddlm Z ddl m Z m Z m Z mZmZmZmZmZddlmZddlmcmcmZddlmZmZdd lmZmZmZm Z m!Z!dd l"m#Z#dd l$m%Z%dd l&m'Z'dd l(m)Z)m*Z*m+Z+ddl,m-Z-ddl.m/Z0ddl1m2Z2ddl3m4Z4ddl5m6Z6m7Z7ddl8m9Z9e rddl:m;Z;mddl?m@Z@ddlAmBZBddlCmDZDhdZEdeFd<dZGdeFd<edZHdeFd<Gd d!ed"#ZIe Gd$d%ZJ d0d&ZK d1 d2d'ZL d3d(ZMd4d)ZNd5d*ZO d6d+ZPd7d,ZQd8d-ZRGd.d/ZSy)9zQCollection of chart commands that are rendered via our vega-lite chart component.) annotationsN) nullcontext) dataclass) TYPE_CHECKINGAnyFinalLiteral TypedDictUnioncastoverload) TypeAlias)dataframe_util type_util)AddRowsMetadataChartStackType ChartTypegenerate_chartmaybe_raise_stack_warning)AttributeDictionary)current_form_id)check_widget_policies)Keycompute_and_register_element_idto_key)StreamlitAPIException)ArrowVegaLiteChart)gather_metrics)get_script_run_ctx)WidgetCallbackregister_widget)HASHLIB_KWARGS)IterableSequence)Data)DeltaGenerator)Color>xyx2y2keyrowhrefsizetextcolorfacetordershapecolumndetailxErroryErroropacitytooltipxError2yError2latitude longitude fillOpacity strokeWidth strokeOpacityr _CHANNELSzdict[str, Any]r VegaLiteSpec)z alt.Chartzalt.ConcatChartzalt.FacetChartzalt.HConcatChartzalt.LayerChartzalt.RepeatChartzalt.VConcatChart AltairChartceZdZUdZded<y) VegaLiteStatea The schema for the Vega-Lite event state. The event state is stored in a dictionary-like object that supports both key and attribute notation. Event states cannot be programmatically changed or set through Session State. Only selection events are supported at this time. Attributes ---------- selection : dict The state of the ``on_select`` event. This attribute returns a dictionary-like object that supports both key and attribute notation. The name of each Vega-Lite selection parameter becomes an attribute in the ``selection`` dictionary. The format of the data within each attribute is determined by the selection parameter definition within Vega-Lite. Examples -------- The following two examples have equivalent definitions. Each one has a point and interval selection parameter include in the chart definition. The point selection parameter is named ``"point_selection"``. The interval or box selection parameter is named ``"interval_selection"``. The follow example uses ``st.altair_chart``: >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> import altair as alt >>> >>> if "data" not in st.session_state: >>> st.session_state.data = pd.DataFrame( ... np.random.randn(20, 3), columns=["a", "b", "c"] ... ) >>> df = st.session_state.data >>> >>> point_selector = alt.selection_point("point_selection") >>> interval_selector = alt.selection_interval("interval_selection") >>> chart = ( ... alt.Chart(df) ... .mark_circle() ... .encode( ... x="a", ... y="b", ... size="c", ... color="c", ... tooltip=["a", "b", "c"], ... fillOpacity=alt.condition(point_selector, alt.value(1), alt.value(0.3)), ... ) ... .add_params(point_selector, interval_selector) ... ) >>> >>> event = st.altair_chart(chart, key="alt_chart", on_select="rerun") >>> >>> event The following example uses ``st.vega_lite_chart``: >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> if "data" not in st.session_state: >>> st.session_state.data = pd.DataFrame( ... np.random.randn(20, 3), columns=["a", "b", "c"] ... ) >>> >>> spec = { ... "mark": {"type": "circle", "tooltip": True}, ... "params": [ ... {"name": "interval_selection", "select": "interval"}, ... {"name": "point_selection", "select": "point"}, ... ], ... "encoding": { ... "x": {"field": "a", "type": "quantitative"}, ... "y": {"field": "b", "type": "quantitative"}, ... "size": {"field": "c", "type": "quantitative"}, ... "color": {"field": "c", "type": "quantitative"}, ... "fillOpacity": { ... "condition": {"param": "point_selection", "value": 1}, ... "value": 0.3, ... }, ... }, ... } >>> >>> event = st.vega_lite_chart( ... st.session_state.data, spec, key="vega_chart", on_select="rerun" ... ) >>> >>> event Try selecting points in this interactive example. When you click a point, the selection will appear under the attribute, ``"point_selection"``, which is the name given to the point selection parameter. Similarly, when you make an interval selection, it will appear under the attribute ``"interval_selection"``. You can give your selection parameters other names if desired. If you hold ``Shift`` while selecting points, existing point selections will be preserved. Interval selections are not preserved when making additional selections. .. output:: https://doc-chart-events-vega-lite-state.streamlit.app height: 600px r selectionN)__name__ __module__ __qualname____doc____annotations__S/var/www/openai/venv/lib/python3.12/site-packages/streamlit/elements/vega_charts.pyrFrFnsm^#"rNrFF)totalc.eZdZUdZded<dddZd dZy) VegaLiteStateSerdezQVegaLiteStateSerde is used to serialize and deserialize the VegaLite Chart state.z Sequence[str]selection_parameterscdt|jDcic]}|ic}i}||n+tttt j |}d|vr|}ttt|Scc}w)NrG)rrSr rFjsonloads)selfui_value widget_idparamempty_selection_stateselection_states rO deserializezVegaLiteStateSerde.deserializes ,(,(A(AB(Au(AB0  "m%8H9M%NO  o -3OM#6#GHHCs A6 c8tj|tS)N)default)rUdumpsstr)rWr\s rO serializezVegaLiteStateSerde.serializeszz/377rNN))rX str | NonerYrareturnrF)r\rFrera)rHrIrJrKrLr]rbrMrNrOrRrRs[''I&8rNrRc t|r%t|fitj|t}n t|}t|dk(r t dd|vrd|vr |r ddd|d<|Sddd|d<|S) Nrz/Vega-Lite charts require a non-empty spec dict.autosizevconcatzfit-xpadding)typecontainsfit)lendict dicttools unflattenrBr)specuse_container_widthkwargss rO_prepare_vega_lite_specrts  6{ DCI// BCDz 4yA~#$UVV  !4(/YGD  K).9ED  KrNcd|vr|djD]l\}}|jj}t||_d|_t |tr|ntj||j_ n|d=d|vr'|d}t |tr d|vr|d}|d=n|}|d=|%tj||j_ yy)zhAdds the data to the proto and removes it from the spec dict. These operations will happen in-place.datasetsTdatavaluesN) itemsrvaddranamehas_name isinstancebytesrconvert_anything_to_arrow_bytesrwrn)protorqrw dataset_name dataset_datadataset data_specs rO_marshall_chart_datarsT*.z*:*@*@*B &L,nn((*G|,GL#G lE2#CCLQ LL +C"  ~L i &9$ *LDV  (HHN rNcddl}idfd }|jjd||jjdk(r|jj dn t 5|jj d5|j}ddddddd<|S#1swYxYw#1swYxYw) z9Convert an Altair chart object to a Vega-Lite chart spec.rNctj|}tjdit}|j t |jd|j}||<d|iS)zAltair data transformer that serializes the data, creates a stable name based on the hash of the data, stores the bytes into the datasets mapping and returns this name to have it be used in Altair. zutf-8r{)md5) rrhashlibnewr"updateraencode hexdigest)rw data_byteshr{rvs rO id_transformz7_convert_altair_to_vega_lite_spec..id_transform\s_$CCDI KK 0 0 Z''01{{}#~rNidr_nonerv)rezdict[str, str])altairdata_transformersregisterthemesactiveenablerto_dict) altair_chartaltr chart_dictrvs @rO!_convert_altair_to_vega_lite_specrOsH"""46 '*jj&7&79&D  6 "+- W  " " ) )$ /%--/J0 X &Jz  0 / X Ws$(B8B,B8,B5 1B88CcLtfddDsdvr tdy)aRaise an exception if the spec contains a multi-view chart (view composition). This is intended to be used as a temporary solution to prevent selections on multi-view charts. There are too many edge cases to handle selections on these charts correctly, so we're disallowing them for now. More information about view compositions: https://vega.github.io/vega-lite/docs/composition.html c3&K|]}|v ywNrM).0r,rqs rO z._disallow_multi_view_charts..s U#TCC4K#Ts)layerhconcatrhconcatrqencodingzSelections are not yet supported for multi-view charts (chart compositions). If you would like to use selections on multi-view charts, please upvote this [Github issue](https://github.com/streamlit/streamlit/issues/8643).N)anyr)rqs`rO_disallow_multi_view_chartsr{s4 U#T UU T !# W   "rNc|rd|vr tSt}|dD]:}|jds|jds'|j|d<|S)zBExtract the names of all valid selection parameters from the spec.paramsr{select)setgetrz)rq param_namesrZs rO_extract_selection_parametersrsY 84'u %Kh 99V 8!4 OOE&M *   rNct|}|s td| t|St|tr|g}|D]}||vstd|d|dt|S)aParse and check the user provided selection modes. This will raise an exception if no valid selection parameters are found in the spec or if the user provided selection modes are not defined in the spec. Parameters ---------- spec : VegaLiteSpec The Vega-Lite chart specification. selection_mode : str, Iterable[str], or None The user provided selection mode(s). Returns ------- list[str] The parsed selection mode(s) that should be activated. aSelections are activated, but the provided chart spec does not have any selections defined. To add selections to `st.altair_chart`, check out the documentation [here](https://altair-viz.github.io/user_guide/interactions.html#selections-capturing-chart-interactions). For adding selections to `st.vega_lite_chart`, take a look at the specification [here](https://vega.github.io/vega-lite/docs/selection.html).zSelection parameter 'zH' is not defined in the chart spec. Available selection parameters are: .)rrsortedr}ra)rqselection_modeall_selection_paramsselection_names rO_parse_selection_moders09> # a  *++.#&()) !5 5'''78==Q rNc eZdZdZed d!ddddddddd d"dZed d!dddddddddd d#d Zed  d!dddddd ddddd d$d Zed d!dddddddddd d%dZe ddddd d&dZ e dddddd d'dZ eddddddd d(dZ e d)ddddd d*dZ e d)dddddd d+dZ ed d)dddddd d,dZ d- d.dZ d/ d0dZ ed1d Zy)2VegaChartsMixinaMMix-in class for all vega-related chart commands. Altair is a python wrapper on top of the vega-lite spec. And our built-in chart commands are just another layer on-top of Altair. All of these chart commands will be eventually converted to a vega-lite spec and rendered using the same vega-lite chart component. line_chartNT)r(r)x_labely_labelr1widthheightrrc ttj||||||d|| \} } td|j | | d| S)a]Display a line chart. This is syntax-sugar around ``st.altair_chart``. The main difference is this command uses the data's own column and indices to figure out the chart's Altair spec. As a result this is easier to use for many "just plot this" scenarios, while being less customizable. If ``st.line_chart`` does not guess the data specification correctly, try specifying your desired chart using ``st.altair_chart``. Parameters ---------- data : Anything supported by st.dataframe Data to be plotted. x : str or None Column name or key associated to the x-axis data. If ``x`` is ``None`` (default), Streamlit uses the data index for the x-axis values. y : str, Sequence of str, or None Column name(s) or key(s) associated to the y-axis data. If this is ``None`` (default), Streamlit draws the data of all remaining columns as data series. If this is a ``Sequence`` of strings, Streamlit draws several series on the same chart by melting your wide-format table into a long-format table behind the scenes. x_label : str or None The label for the x-axis. If this is ``None`` (default), Streamlit will use the column name specified in ``x`` if available, or else no label will be displayed. y_label : str or None The label for the y-axis. If this is ``None`` (default), Streamlit will use the column name(s) specified in ``y`` if available, or else no label will be displayed. color : str, tuple, Sequence of str, Sequence of tuple, or None The color to use for different lines in this chart. For a line chart with just one line, this can be: - None, to use the default color. - A hex string like "#ffaa00" or "#ffaa0088". - An RGB or RGBA tuple with the red, green, blue, and alpha components specified as ints from 0 to 255 or floats from 0.0 to 1.0. For a line chart with multiple lines, where the dataframe is in long format (that is, y is None or just one column), this can be: - None, to use the default colors. - The name of a column in the dataset. Data points will be grouped into lines of the same color based on the value of this column. In addition, if the values in this column match one of the color formats above (hex string or color tuple), then that color will be used. For example: if the dataset has 1000 rows, but this column only contains the values "adult", "child", and "baby", then those 1000 datapoints will be grouped into three lines whose colors will be automatically selected from the default palette. But, if for the same 1000-row dataset, this column contained the values "#ffaa00", "#f0f", "#0000ff", then then those 1000 datapoints would still be grouped into three lines, but their colors would be "#ffaa00", "#f0f", "#0000ff" this time around. For a line chart with multiple lines, where the dataframe is in wide format (that is, y is a Sequence of columns), this can be: - None, to use the default colors. - A list of string colors or color tuples to be used for each of the lines in the chart. This list should have the same length as the number of y values (e.g. ``color=["#fd0", "#f0f", "#04f"]`` for three lines). width : int or None Desired width of the chart expressed in pixels. If ``width`` is ``None`` (default), Streamlit sets the width of the chart to fit its contents according to the plotting library, up to the width of the parent container. If ``width`` is greater than the width of the parent container, Streamlit sets the chart width to match the width of the parent container. To use ``width``, you must set ``use_container_width=False``. height : int or None Desired height of the chart expressed in pixels. If ``height`` is ``None`` (default), Streamlit sets the height of the chart to fit its contents according to the plotting library. use_container_width : bool Whether to override ``width`` with the width of the parent container. If ``use_container_width`` is ``True`` (default), Streamlit sets the width of the chart to match the width of the parent container. If ``use_container_width`` is ``False``, Streamlit sets the chart's width according to ``width``. Examples -------- >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"]) >>> >>> st.line_chart(chart_data) .. output:: https://doc-line-chart.streamlit.app/ height: 440px You can also choose different columns to use for x and y, as well as set the color dynamically based on a 3rd column (assuming your dataframe is in long format): >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... { ... "col1": np.random.randn(20), ... "col2": np.random.randn(20), ... "col3": np.random.choice(["A", "B", "C"], 20), ... } ... ) >>> >>> st.line_chart(chart_data, x="col1", y="col2", color="col3") .. output:: https://doc-line-chart1.streamlit.app/ height: 440px Finally, if your dataframe is in wide format, you can group multiple columns under the y argument to show multiple lines with different colors: >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... np.random.randn(20, 3), columns=["col1", "col2", "col3"] ... ) >>> >>> st.line_chart( ... chart_data, ... x="col1", ... y=["col2", "col3"], ... color=["#FF0000", "#0000FF"], # Optional ... ) .. output:: https://doc-line-chart2.streamlit.app/ height: 440px N chart_typerw x_from_user y_from_user x_axis_label y_axis_labelcolor_from_usersize_from_userrrr& streamlitrrthemeadd_rows_metadata)rrLINEr _altair_chart) rWrwr(r)rrr1rrrrchartrs rOrzVegaChartsMixin.line_chart2sh\$2 ~~  ! $       $7!"3    rN area_chart) r(r)rrr1stackrrrrc t|dd|dus|d}ttj||||||d|| | \} } t d|j | | d| S) aDisplay an area chart. This is syntax-sugar around ``st.altair_chart``. The main difference is this command uses the data's own column and indices to figure out the chart's Altair spec. As a result this is easier to use for many "just plot this" scenarios, while being less customizable. If ``st.area_chart`` does not guess the data specification correctly, try specifying your desired chart using ``st.altair_chart``. Parameters ---------- data : Anything supported by st.dataframe Data to be plotted. x : str or None Column name or key associated to the x-axis data. If ``x`` is ``None`` (default), Streamlit uses the data index for the x-axis values. y : str, Sequence of str, or None Column name(s) or key(s) associated to the y-axis data. If this is ``None`` (default), Streamlit draws the data of all remaining columns as data series. If this is a ``Sequence`` of strings, Streamlit draws several series on the same chart by melting your wide-format table into a long-format table behind the scenes. x_label : str or None The label for the x-axis. If this is ``None`` (default), Streamlit will use the column name specified in ``x`` if available, or else no label will be displayed. y_label : str or None The label for the y-axis. If this is ``None`` (default), Streamlit will use the column name(s) specified in ``y`` if available, or else no label will be displayed. color : str, tuple, Sequence of str, Sequence of tuple, or None The color to use for different series in this chart. For an area chart with just 1 series, this can be: - None, to use the default color. - A hex string like "#ffaa00" or "#ffaa0088". - An RGB or RGBA tuple with the red, green, blue, and alpha components specified as ints from 0 to 255 or floats from 0.0 to 1.0. For an area chart with multiple series, where the dataframe is in long format (that is, y is None or just one column), this can be: - None, to use the default colors. - The name of a column in the dataset. Data points will be grouped into series of the same color based on the value of this column. In addition, if the values in this column match one of the color formats above (hex string or color tuple), then that color will be used. For example: if the dataset has 1000 rows, but this column only contains the values "adult", "child", and "baby", then those 1000 datapoints will be grouped into three series whose colors will be automatically selected from the default palette. But, if for the same 1000-row dataset, this column contained the values "#ffaa00", "#f0f", "#0000ff", then then those 1000 datapoints would still be grouped into 3 series, but their colors would be "#ffaa00", "#f0f", "#0000ff" this time around. For an area chart with multiple series, where the dataframe is in wide format (that is, y is a Sequence of columns), this can be: - None, to use the default colors. - A list of string colors or color tuples to be used for each of the series in the chart. This list should have the same length as the number of y values (e.g. ``color=["#fd0", "#f0f", "#04f"]`` for three lines). stack : bool, "normalize", "center", or None Whether to stack the areas. If this is ``None`` (default), Streamlit uses Vega's default. Other values can be as follows: - ``True``: The areas form a non-overlapping, additive stack within the chart. - ``False``: The areas overlap each other without stacking. - ``"normalize"``: The areas are stacked and the total height is normalized to 100% of the height of the chart. - ``"center"``: The areas are stacked and shifted to center their baseline, which creates a steamgraph. width : int or None Desired width of the chart expressed in pixels. If ``width`` is ``None`` (default), Streamlit sets the width of the chart to fit its contents according to the plotting library, up to the width of the parent container. If ``width`` is greater than the width of the parent container, Streamlit sets the chart width to match the width of the parent container. To use ``width``, you must set ``use_container_width=False``. height : int or None Desired height of the chart expressed in pixels. If ``height`` is ``None`` (default), Streamlit sets the height of the chart to fit its contents according to the plotting library. use_container_width : bool Whether to override ``width`` with the width of the parent container. If ``use_container_width`` is ``True`` (default), Streamlit sets the width of the chart to match the width of the parent container. If ``use_container_width`` is ``False``, Streamlit sets the chart's width according to ``width``. Examples -------- >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"]) >>> >>> st.area_chart(chart_data) .. output:: https://doc-area-chart.streamlit.app/ height: 440px You can also choose different columns to use for x and y, as well as set the color dynamically based on a 3rd column (assuming your dataframe is in long format): >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... { ... "col1": np.random.randn(20), ... "col2": np.random.randn(20), ... "col3": np.random.choice(["A", "B", "C"], 20), ... } ... ) >>> >>> st.area_chart(chart_data, x="col1", y="col2", color="col3") .. output:: https://doc-area-chart1.streamlit.app/ height: 440px If your dataframe is in wide format, you can group multiple columns under the y argument to show multiple series with different colors: >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... np.random.randn(20, 3), columns=["col1", "col2", "col3"] ... ) >>> >>> st.area_chart( ... chart_data, ... x="col1", ... y=["col2", "col3"], ... color=["#FF0000", "#0000FF"], # Optional ... ) .. output:: https://doc-area-chart2.streamlit.app/ height: 440px You can adjust the stacking behavior by setting ``stack``. Create a steamgraph: >>> import streamlit as st >>> from vega_datasets import data >>> >>> source = data.unemployment_across_industries() >>> >>> st.area_chart(source, x="date", y="count", color="series", stack="center") .. output:: https://doc-area-chart-steamgraph.streamlit.app/ height: 440px z st.area_chartzDhttps://docs.streamlit.io/develop/api-reference/charts/st.area_chartFNlayered rrwrrrrrrrrrr&rr)rrrAREAr r) rWrwr(r)rrr1rrrrrrrs rOrzVegaChartsMixin.area_chartsT "   R  E>U]E#1 ~~  ! $       $7!"3    rN bar_chartF) r(r)rrr1 horizontalrrrrrc t|ddtjdr|dur td|rtj ntj } t| ||||||d| | | \} }td|j| | d | S) ay!Display a bar chart. This is syntax-sugar around ``st.altair_chart``. The main difference is this command uses the data's own column and indices to figure out the chart's Altair spec. As a result this is easier to use for many "just plot this" scenarios, while being less customizable. If ``st.bar_chart`` does not guess the data specification correctly, try specifying your desired chart using ``st.altair_chart``. Parameters ---------- data : Anything supported by st.dataframe Data to be plotted. x : str or None Column name or key associated to the x-axis data. If ``x`` is ``None`` (default), Streamlit uses the data index for the x-axis values. y : str, Sequence of str, or None Column name(s) or key(s) associated to the y-axis data. If this is ``None`` (default), Streamlit draws the data of all remaining columns as data series. If this is a ``Sequence`` of strings, Streamlit draws several series on the same chart by melting your wide-format table into a long-format table behind the scenes. x_label : str or None The label for the x-axis. If this is ``None`` (default), Streamlit will use the column name specified in ``x`` if available, or else no label will be displayed. y_label : str or None The label for the y-axis. If this is ``None`` (default), Streamlit will use the column name(s) specified in ``y`` if available, or else no label will be displayed. color : str, tuple, Sequence of str, Sequence of tuple, or None The color to use for different series in this chart. For a bar chart with just one series, this can be: - None, to use the default color. - A hex string like "#ffaa00" or "#ffaa0088". - An RGB or RGBA tuple with the red, green, blue, and alpha components specified as ints from 0 to 255 or floats from 0.0 to 1.0. For a bar chart with multiple series, where the dataframe is in long format (that is, y is None or just one column), this can be: - None, to use the default colors. - The name of a column in the dataset. Data points will be grouped into series of the same color based on the value of this column. In addition, if the values in this column match one of the color formats above (hex string or color tuple), then that color will be used. For example: if the dataset has 1000 rows, but this column only contains the values "adult", "child", and "baby", then those 1000 datapoints will be grouped into three series whose colors will be automatically selected from the default palette. But, if for the same 1000-row dataset, this column contained the values "#ffaa00", "#f0f", "#0000ff", then then those 1000 datapoints would still be grouped into 3 series, but their colors would be "#ffaa00", "#f0f", "#0000ff" this time around. For a bar chart with multiple series, where the dataframe is in wide format (that is, y is a Sequence of columns), this can be: - None, to use the default colors. - A list of string colors or color tuples to be used for each of the series in the chart. This list should have the same length as the number of y values (e.g. ``color=["#fd0", "#f0f", "#04f"]`` for three lines). horizontal : bool Whether to make the bars horizontal. If this is ``False`` (default), the bars display vertically. If this is ``True``, Streamlit swaps the x-axis and y-axis and the bars display horizontally. stack : bool, "normalize", "center", "layered", or None Whether to stack the bars. If this is ``None`` (default), Streamlit uses Vega's default. Other values can be as follows: - ``True``: The bars form a non-overlapping, additive stack within the chart. - ``False``: The bars display side by side. - ``"layered"``: The bars overlap each other without stacking. - ``"normalize"``: The bars are stacked and the total height is normalized to 100% of the height of the chart. - ``"center"``: The bars are stacked and shifted to center the total height around an axis. width : int or None Desired width of the chart expressed in pixels. If ``width`` is ``None`` (default), Streamlit sets the width of the chart to fit its contents according to the plotting library, up to the width of the parent container. If ``width`` is greater than the width of the parent container, Streamlit sets the chart width to match the width of the parent container. To use ``width``, you must set ``use_container_width=False``. height : int or None Desired height of the chart expressed in pixels. If ``height`` is ``None`` (default), Streamlit sets the height of the chart to fit its contents according to the plotting library. use_container_width : bool Whether to override ``width`` with the width of the parent container. If ``use_container_width`` is ``True`` (default), Streamlit sets the width of the chart to match the width of the parent container. If ``use_container_width`` is ``False``, Streamlit sets the chart's width according to ``width``. Examples -------- >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"]) >>> >>> st.bar_chart(chart_data) .. output:: https://doc-bar-chart.streamlit.app/ height: 440px You can also choose different columns to use for x and y, as well as set the color dynamically based on a 3rd column (assuming your dataframe is in long format): >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... { ... "col1": list(range(20)) * 3, ... "col2": np.random.randn(60), ... "col3": ["A"] * 20 + ["B"] * 20 + ["C"] * 20, ... } ... ) >>> >>> st.bar_chart(chart_data, x="col1", y="col2", color="col3") .. output:: https://doc-bar-chart1.streamlit.app/ height: 440px If your dataframe is in wide format, you can group multiple columns under the y argument to show multiple series with different colors: >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... { ... "col1": list(range(20)), ... "col2": np.random.randn(20), ... "col3": np.random.randn(20), ... } ... ) >>> >>> st.bar_chart( ... chart_data, ... x="col1", ... y=["col2", "col3"], ... color=["#FF0000", "#0000FF"], # Optional ... ) .. output:: https://doc-bar-chart2.streamlit.app/ height: 440px You can rotate your bar charts to display horizontally. >>> import streamlit as st >>> from vega_datasets import data >>> >>> source = data.barley() >>> >>> st.bar_chart(source, x="variety", y="yield", color="site", horizontal=True) .. output:: https://doc-bar-chart-horizontal.streamlit.app/ height: 440px You can unstack your bar charts. >>> import streamlit as st >>> from vega_datasets import data >>> >>> source = data.barley() >>> >>> st.bar_chart(source, x="year", y="yield", color="site", stack=False) .. output:: https://doc-bar-chart-unstacked.streamlit.app/ height: 440px z st.bar_chartzChttps://docs.streamlit.io/develop/api-reference/charts/st.bar_chart5.0.0FziStreamlit does not support non-stacked (grouped) bar charts with Altair 4.x. Please upgrade to Version 5.Nrr&rr) rris_altair_version_less_thanrrHORIZONTAL_BAR VERTICAL_BARrr r)rWrwr(r)rrr1rrrrrrbar_chart_typerrs rOrzVegaChartsMixin.bar_chartsD "   Q   0 0 9eun';  )3I $ $ 8N8N $2%  ! $       $7!"3    rN scatter_chart) r(r)rrr1r/rrrrc ttj|||||||||  \} } td|j | | d| S)a[Display a scatterplot chart. This is syntax-sugar around ``st.altair_chart``. The main difference is this command uses the data's own column and indices to figure out the chart's Altair spec. As a result this is easier to use for many "just plot this" scenarios, while being less customizable. If ``st.scatter_chart`` does not guess the data specification correctly, try specifying your desired chart using ``st.altair_chart``. Parameters ---------- data : Anything supported by st.dataframe Data to be plotted. x : str or None Column name or key associated to the x-axis data. If ``x`` is ``None`` (default), Streamlit uses the data index for the x-axis values. y : str, Sequence of str, or None Column name(s) or key(s) associated to the y-axis data. If this is ``None`` (default), Streamlit draws the data of all remaining columns as data series. If this is a ``Sequence`` of strings, Streamlit draws several series on the same chart by melting your wide-format table into a long-format table behind the scenes. x_label : str or None The label for the x-axis. If this is ``None`` (default), Streamlit will use the column name specified in ``x`` if available, or else no label will be displayed. y_label : str or None The label for the y-axis. If this is ``None`` (default), Streamlit will use the column name(s) specified in ``y`` if available, or else no label will be displayed. color : str, tuple, Sequence of str, Sequence of tuple, or None The color of the circles representing each datapoint. This can be: - None, to use the default color. - A hex string like "#ffaa00" or "#ffaa0088". - An RGB or RGBA tuple with the red, green, blue, and alpha components specified as ints from 0 to 255 or floats from 0.0 to 1.0. - The name of a column in the dataset where the color of that datapoint will come from. If the values in this column are in one of the color formats above (hex string or color tuple), then that color will be used. Otherwise, the color will be automatically picked from the default palette. For example: if the dataset has 1000 rows, but this column only contains the values "adult", "child", and "baby", then those 1000 datapoints be shown using three colors from the default palette. But if this column only contains floats or ints, then those 1000 datapoints will be shown using a colors from a continuous color gradient. Finally, if this column only contains the values "#ffaa00", "#f0f", "#0000ff", then then each of those 1000 datapoints will be assigned "#ffaa00", "#f0f", or "#0000ff" as appropriate. If the dataframe is in wide format (that is, y is a Sequence of columns), this can also be: - A list of string colors or color tuples to be used for each of the series in the chart. This list should have the same length as the number of y values (e.g. ``color=["#fd0", "#f0f", "#04f"]`` for three series). size : str, float, int, or None The size of the circles representing each point. This can be: - A number like 100, to specify a single size to use for all datapoints. - The name of the column to use for the size. This allows each datapoint to be represented by a circle of a different size. width : int or None Desired width of the chart expressed in pixels. If ``width`` is ``None`` (default), Streamlit sets the width of the chart to fit its contents according to the plotting library, up to the width of the parent container. If ``width`` is greater than the width of the parent container, Streamlit sets the chart width to match the width of the parent container. To use ``width``, you must set ``use_container_width=False``. height : int or None Desired height of the chart expressed in pixels. If ``height`` is ``None`` (default), Streamlit sets the height of the chart to fit its contents according to the plotting library. use_container_width : bool Whether to override ``width`` with the width of the parent container. If ``use_container_width`` is ``True`` (default), Streamlit sets the width of the chart to match the width of the parent container. If ``use_container_width`` is ``False``, Streamlit sets the chart's width according to ``width``. Examples -------- >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"]) >>> >>> st.scatter_chart(chart_data) .. output:: https://doc-scatter-chart.streamlit.app/ height: 440px You can also choose different columns to use for x and y, as well as set the color dynamically based on a 3rd column (assuming your dataframe is in long format): >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... np.random.randn(20, 3), columns=["col1", "col2", "col3"] ... ) >>> chart_data["col4"] = np.random.choice(["A", "B", "C"], 20) >>> >>> st.scatter_chart( ... chart_data, ... x="col1", ... y="col2", ... color="col4", ... size="col3", ... ) .. output:: https://doc-scatter-chart1.streamlit.app/ height: 440px Finally, if your dataframe is in wide format, you can group multiple columns under the y argument to show multiple series with different colors: >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame( ... np.random.randn(20, 4), columns=["col1", "col2", "col3", "col4"] ... ) >>> >>> st.scatter_chart( ... chart_data, ... x="col1", ... y=["col2", "col3"], ... size="col4", ... color=["#FF0000", "#0000FF"], # Optional ... ) .. output:: https://doc-scatter-chart2.streamlit.app/ height: 440px rr&rr)rrSCATTERr r) rWrwr(r)rrr1r/rrrrrrs rOrzVegaChartsMixin.scatter_chartsjx$2 ((  ! $       $7!"3    rNr)rrrr,rrcyrrMrWrrrrr, on_selectrs rOrzVegaChartsMixin.altair_chartsrNrerun)rrrr,rrcyrrMrs rOrzVegaChartsMixin.altair_chartsrNignorec0|j||||||S)aZDisplay a chart using the Vega-Altair library. `Vega-Altair `_ is a declarative statistical visualization library for Python, based on Vega and Vega-Lite. Parameters ---------- altair_chart : altair.Chart The Altair chart object to display. See https://altair-viz.github.io/gallery/ for examples of graph descriptions. use_container_width : bool or None Whether to override the chart's native width with the width of the parent container. This can be one of the following: - ``None`` (default): Streamlit will use the parent container's width for all charts except those with known incompatibility (``altair.Facet``, ``altair.HConcatChart``, and ``altair.RepeatChart``). - ``True``: Streamlit sets the width of the chart to match the width of the parent container. - ``False``: Streamlit sets the width of the chart to fit its contents according to the plotting library, up to the width of the parent container. theme : "streamlit" or None The theme of the chart. If ``theme`` is ``"streamlit"`` (default), Streamlit uses its own design default. If ``theme`` is ``None``, Streamlit falls back to the default behavior of the library. key : str An optional string to use for giving this element a stable identity. If ``key`` is ``None`` (default), this element's identity will be determined based on the values of the other parameters. Additionally, if selections are activated and ``key`` is provided, Streamlit will register the key in Session State to store the selection state. The selection state is read-only. on_select : "ignore", "rerun", or callable How the figure should respond to user selection events. This controls whether or not the figure behaves like an input widget. ``on_select`` can be one of the following: - ``"ignore"`` (default): Streamlit will not react to any selection events in the chart. The figure will not behave like an input widget. - ``"rerun"``: Streamlit will rerun the app when the user selects data in the chart. In this case, ``st.altair_chart`` will return the selection data as a dictionary. - A ``callable``: Streamlit will rerun the app and execute the ``callable`` as a callback function before the rest of the app. In this case, ``st.altair_chart`` will return the selection data as a dictionary. To use selection events, the object passed to ``altair_chart`` must include selection paramters. To learn about defining interactions in Altair and how to declare selection-type parameters, see `Interactive Charts `_ in Altair's documentation. selection_mode : str or Iterable of str The selection parameters Streamlit should use. If ``selection_mode`` is ``None`` (default), Streamlit will use all selection parameters defined in the chart's Altair spec. When Streamlit uses a selection parameter, selections from that parameter will trigger a rerun and be included in the selection state. When Streamlit does not use a selection parameter, selections from that parameter will not trigger a rerun and not be included in the selection state. Selection parameters are identified by their ``name`` property. Returns ------- element or dict If ``on_select`` is ``"ignore"`` (default), this command returns an internal placeholder for the chart element that can be used with the ``.add_rows()`` method. Otherwise, this command returns a dictionary-like object that supports both key and attribute notation. The attributes are described by the ``VegaLiteState`` dictionary schema. Example ------- >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> import altair as alt >>> >>> chart_data = pd.DataFrame(np.random.randn(20, 3), columns=["a", "b", "c"]) >>> >>> c = ( ... alt.Chart(chart_data) ... .mark_circle() ... .encode(x="a", y="b", size="c", color="c", tooltip=["a", "b", "c"]) ... ) >>> >>> st.altair_chart(c) .. output:: https://doc-vega-lite-chart.streamlit.app/ height: 450px )rrrrr,rr)rrs rOrzVegaChartsMixin.altair_charts/v!!% 3) "  rNc yrrM rWrwrqrrrr,rrrss rOvega_lite_chartzVegaChartsMixin.vega_lite_chartbsrNc yrrMrs rOrzVegaChartsMixin.vega_lite_chartqsrNrc 6|jd|||||||d|S)aDisplay a chart using the Vega-Lite library. `Vega-Lite `_ is a high-level grammar for defining interactive graphics. Parameters ---------- data : Anything supported by st.dataframe Either the data to be plotted or a Vega-Lite spec containing the data (which more closely follows the Vega-Lite API). spec : dict or None The Vega-Lite spec for the chart. If ``spec`` is ``None`` (default), Streamlit uses the spec passed in ``data``. You cannot pass a spec to both ``data`` and ``spec``. See https://vega.github.io/vega-lite/docs/ for more info. use_container_width : bool or None Whether to override the chart's native width with the width of the parent container. This can be one of the following: - ``None`` (default): Streamlit will use the parent container's width for all charts except those with known incompatibility (``altair.Facet``, ``altair.HConcatChart``, and ``altair.RepeatChart``). - ``True``: Streamlit sets the width of the chart to match the width of the parent container. - ``False``: Streamlit sets the width of the chart to fit its contents according to the plotting library, up to the width of the parent container. theme : "streamlit" or None The theme of the chart. If ``theme`` is ``"streamlit"`` (default), Streamlit uses its own design default. If ``theme`` is ``None``, Streamlit falls back to the default behavior of the library. key : str An optional string to use for giving this element a stable identity. If ``key`` is ``None`` (default), this element's identity will be determined based on the values of the other parameters. Additionally, if selections are activated and ``key`` is provided, Streamlit will register the key in Session State to store the selection state. The selection state is read-only. on_select : "ignore", "rerun", or callable How the figure should respond to user selection events. This controls whether or not the figure behaves like an input widget. ``on_select`` can be one of the following: - ``"ignore"`` (default): Streamlit will not react to any selection events in the chart. The figure will not behave like an input widget. - ``"rerun"``: Streamlit will rerun the app when the user selects data in the chart. In this case, ``st.vega_lite_chart`` will return the selection data as a dictionary. - A ``callable``: Streamlit will rerun the app and execute the ``callable`` as a callback function before the rest of the app. In this case, ``st.vega_lite_chart`` will return the selection data as a dictionary. To use selection events, the Vega-Lite spec defined in ``data`` or ``spec`` must include selection parameters from the the charting library. To learn about defining interactions in Vega-Lite, see `Dynamic Behaviors with Parameters `_ in Vega-Lite's documentation. selection_mode : str or Iterable of str The selection parameters Streamlit should use. If ``selection_mode`` is ``None`` (default), Streamlit will use all selection parameters defined in the chart's Vega-Lite spec. When Streamlit uses a selection parameter, selections from that parameter will trigger a rerun and be included in the selection state. When Streamlit does not use a selection parameter, selections from that parameter will not trigger a rerun and not be included in the selection state. Selection parameters are identified by their ``name`` property. **kwargs : any The Vega-Lite spec for the chart as keywords. This is an alternative to ``spec``. Returns ------- element or dict If ``on_select`` is ``"ignore"`` (default), this command returns an internal placeholder for the chart element that can be used with the ``.add_rows()`` method. Otherwise, this command returns a dictionary-like object that supports both key and attribute notation. The attributes are described by the ``VegaLiteState`` dictionary schema. Example ------- >>> import streamlit as st >>> import pandas as pd >>> import numpy as np >>> >>> chart_data = pd.DataFrame(np.random.randn(200, 3), columns=["a", "b", "c"]) >>> >>> st.vega_lite_chart( ... chart_data, ... { ... "mark": {"type": "circle", "tooltip": True}, ... "encoding": { ... "x": {"field": "a", "type": "quantitative"}, ... "y": {"field": "b", "type": "quantitative"}, ... "size": {"field": "c", "type": "quantitative"}, ... "color": {"field": "c", "type": "quantitative"}, ... }, ... }, ... ) .. output:: https://doc-vega-lite-chart.streamlit.app/ height: 450px Examples of Vega-Lite usage without Streamlit can be found at https://vega.github.io/vega-lite/examples/. Most of those can be easily translated to the syntax shown above. )rwrqrrrr,rrrM)_vega_lite_chartrs rOrzVegaChartsMixin.vega_lite_charts>X%t$$   3)    rNc tjdr|dk7r tdt|}|j d|||||||S)zInternal method to enqueue a vega-lite chart element based on an Altair chart. See the `altair_chart` method docstring for more information. rrzStreamlit does not support selections with Altair 4.x. Please upgrade to Version 5. If you would like to use Altair 4.x with selections, please upvote this [Github issue](https://github.com/streamlit/streamlit/issues/8516).N)rwrqrrrr,rrr)rrrrr) rWrrrrr,rrrvega_lite_specs rOrzVegaChartsMixin._altair_chartsh  0 0 9i8>S'[ ;<H$$ 3)/%  rNc <|dvrtd|d|dvrt|std|dt|}|dk7} | r8t|} t|j|| rt t |nddd | t|tr|d}i|/d vxsd vxrtfd dD} | xs dvxsdv }t} t|fi| t| |ttj| _|| _|xsd| _| rWtj&| j }t)|t+||}| j,j/|t1|j| _t5}t7d|| j2| j | j8j8| j:Dcgc]}|j<c}||| | _tA|}tC| j>t|r|nd|jD|jF|d}|jjId| |t tJ|jLS|jjId| |Scc}w)zInternal method to enqueue a vega-lite chart element based on a vega-lite spec. See the `vega_lite_chart` method docstring for more information. )rNzYou set theme="us" while Streamlit charts only support theme=”streamlit” or theme=None to fallback to the default library theme.)rrzYou have passed zH to `on_select`. But only 'ignore', 'rerun', or a callable is supported.rNF) on_change default_valuewrites_allowedenable_check_callback_rulesr2rc3,K|] }|dv yw)rNrM)rr(rqs rOrz3VegaChartsMixin._vega_lite_chart..zsS8R1d:..8Rs)r-r5r2rrepeatrcarrow_vega_lite_chart)user_keyform_idrvega_lite_datanamed_datasetsrrrr string_value)on_change_handler deserializer serializerctx value_type)r)'rcallablerrdgr r r}rnrArrowVegaLiteChartProtortrrrUr`rqrrrrVrrrextendrrrrrwrvr{rrRr!r]rb_enqueuerFvalue)rWrwrqrrrr,rrrrsis_selection_activated is_callbackis_facet_chartvega_lite_proto final_specparsed_selection_modesrrserde widget_states ` rOrz VegaChartsMixin._vega_lite_chart9s" + +'!%)!!  / /8K'"9+.77  Sk!*h!6 !#9-K !=H$~y9d"$,7   dD !dlDD <D  &%_d"US8RSS  G)t"3Gx47G# 23&t-@KFK_dD9 9D9IJ.A+ %  !O$8$89J ' 3&;:~%V "  * * 1 12H I&5dgg&>O #$&C!@''//.33 /3388=LE*""/7 /B)".. ??) L GG  '"3    |'9'9: :ww # /   3 VsJctd|S)zGet our DeltaGenerator.r&)r )rWs rOrzVegaChartsMixin.dgs$d++rNr)rwr%r(rdr)str | Sequence[str] | Nonerrdrrdr1 str | Color | list[Color] | Noner int | Nonerr*rrboolrer&)rwr%r(rdr)r(rrdrrdr1r)rbool | ChartStackType | Nonerr*rr*rrr+rer&)rwr%r(rdr)r(rrdrrdr1r)rr+rr,rr*rr*rrr+rer&)rwr%r(rdr)r(rrdrrdr1r)r/zstr | float | int | Nonerr*rr*rrr+rer&)rrDrr bool | NonerLiteral['streamlit'] | Noner, Key | NonerLiteral['ignore']rstr | Iterable[str] | Nonerer&)rrDrrr-rr.r,r/r!Literal['rerun'] | WidgetCallbackrr1rerF)rrDrrr-rr.r,r/r+Literal['rerun', 'ignore'] | WidgetCallbackrr1reDeltaGenerator | VegaLiteState)NN)rwr%rqVegaLiteSpec | Nonerrr-rr.r,r/rr0rr1rsrrer&)rwr%rqr5rrr-rr.r,r/rr2rr1rsrrerF)rwr%rqr5rrr-rr.r,r/rr3rr1rsrrer4)NrNrNN)rrDrrr-rr.r,r/rr3rr1rAddRowsMetadata | Nonerer4)NNNrNrNN)rwr%rqr5rrr-rr.r,r/rr3rr1rr6rsrrer4)rer&)rHrIrJrKrrrrrr rrrrpropertyrrMrNrOrr)sL!A (,""26 !$(A A   A & A  A A 0A A A "A  A "A FL!n (,""26.2 !$(n n   n & n  n n 0n ,n n n "n  n "n `K G (,""26 .2 !$(G G   G & G  G G 0G G ,G G G "G  G !G RO$O (,""26)- !$(O O   O & O  O O 0O 'O O O "O  O %O d ,0-859 ! )  +   % 3     ,0-87>59 ! )  +   5 3    N# ,0-8AI59A !A ) A + A  A ?A 3A  (A $A H$(  ,0-859  "  )  +  % 3     $(  ,0-87>59  "  )  +  5 3     %&$(T ,0-8AI59T T "T ) T + T T ?T 3T T  (T 'T r,0-8AI5948! !! )! + !  ! ? ! 3! 2!  (! J$(+/-8AI5948E E "E ) E + E  E ?E 3E 2E E  (E N,,rNr)rqrCrrr+rerCr)rrrqrCrwr%reNone)rrDrerC)rqrCrer8)rqrCrezset[str])rqrCrr1rez list[str])rrarrarera)rrarera)TrK __future__rrrUr contextlibr dataclassesrtypingrrrr r r r r typing_extensionsr streamlit.elements.lib.dicttoolselementslibrorrr+streamlit.elements.lib.built_in_chart_utilsrrrrr"streamlit.elements.lib.event_utilsr!streamlit.elements.lib.form_utilsrstreamlit.elements.lib.policiesrstreamlit.elements.lib.utilsrrrstreamlit.errorsr&streamlit.proto.ArrowVegaLiteChart_pb2rrstreamlit.runtime.metrics_utilr7streamlit.runtime.scriptrunner_utils.script_run_contextrstreamlit.runtime.stater r!streamlit.utilr"collections.abcr#r$rrstreamlit.dataframe_utilr%streamlit.delta_generatorr&!streamlit.elements.lib.color_utilr'rBrLrCrDrFrRrtrrrrrrrrrMrNrOrPsX" "!   (44/C=AUU2:VC)2-87 5:+ i* Yp#IUp#f 88 88  D/O "/O /O /O /Od)))X *"2" 2".2"2"jB/dZ,Z,rN