chd%SSKJr SSKJr SSKJrJrJrJr SSK J r SSK J r SSK JrJrJrJrJrJrJrJrJrJrJrJrJrJrJr SSKJrJrJ r SSK!J"r"J#r#J$r$ SS K%J&r' SS K(J)r) SS K*J+r+ SS K,J-r- \(aSS K.J/r/ SSK0J1r1 SSK2J3r3 SSK4J5r5 \\6\\\6\744r8S\9S'"SS5r:g)) annotations)Sequence) TYPE_CHECKINGLiteralUnioncast) TypeAlias)get_dg_singleton_instance)GapHeightHorizontalAlignmentVerticalAlignmentWidthWidthWithoutContent get_align get_gap_sizeget_height_config get_justifyget_width_configvalidate_heightvalidate_horizontal_alignmentvalidate_vertical_alignmentvalidate_width)Keycompute_and_register_element_idto_key)StreamlitAPIExceptionStreamlitInvalidColumnSpecError&StreamlitInvalidVerticalAlignmentError)Block) GapConfig)gather_metrics)validate_icon_or_emoji)DeltaGenerator)Dialog)StatusContainer)WidgetCallbackr SpecTypec \rSrSr\"S5SSSSSSSS S .S"S jj5r\"S 5S SSSS .S#Sjj5r\"S5SS.S$Sjj5r\"S5S%SSS.S&Sjjj5r\"S5SSSSSS.S'Sjj5r \"S5SSSS.S(Sjj5r SS SS.S)Sjjr \ S*S j5r S!rg)+ LayoutsMixin< containerNstretchcontentFlefttopsmall)borderkeywidthheight horizontalhorizontal_alignmentvertical_alignmentgapc[U5n[5n SU lU=(d SU Rl[ US5U RR l[U5 [U5 U(aySU Rl [RRRU Rl[U5U Rl[#U5U RlOxSU Rl [RRR&U Rl[U5U Rl[#U5U Rl[)U5 U R*R-[/U55 [1U[25(dU(aSU lUbXRlO8[1U[25(aSU RlOSU Rl[5USS9 U R6R-[9U55 U(a[;SUSS9U lUR>RAU 5$)a!Insert a multi-element container. Inserts an invisible container into your app that can be used to hold multiple elements. This allows you to, for example, insert multiple elements into your app out of order. To add elements to the returned container, you can use the ``with`` notation (preferred) or just call commands directly on the returned object. See examples below. Parameters ---------- border : bool or None Whether to show a border around the container. If ``None`` (default), a border is shown if the container is set to a fixed height and not shown otherwise. key : str or None An optional string to give this container a stable identity. Additionally, if ``key`` is provided, it will be used as CSS class name prefixed with ``st-key-``. width : "stretch" or int The width of the container. This can be one of the following: - ``"stretch"`` (default): The width of the container matches the width of the parent container. - An integer specifying the width in pixels: The container has a fixed width. If the specified width is greater than the width of the parent container, the width of the container matches the width of the parent container. height : "content", "stretch", or int The height of the container. This can be one of the following: - ``"content"`` (default): The height of the container matches the height of its content. - ``"stretch"``: The height of the container matches the height of its content or the height of the parent container, whichever is larger. If the container is not in a parent container, the height of the container matches the height of its content. - An integer specifying the height in pixels: The container has a fixed height. If the content is larger than the specified height, scrolling is enabled. .. note:: Use scrolling containers sparingly. If you use scrolling containers, avoid heights that exceed 500 pixels. Otherwise, the scroll surface of the container might cover the majority of the screen on mobile devices, which makes it hard to scroll the rest of the app. horizontal : bool Whether to use horizontal flexbox layout. If this is ``False`` (default), the container's elements are laid out vertically. If this is ``True``, the container's elements are laid out horizontally and will overflow to the next line if they don't fit within the container's width. horizontal_alignment : "left", "center", "right", or "distribute" The horizontal alignment of the elements inside the container. This can be one of the following: - ``"left"`` (default): Elements are aligned to the left side of the container. - ``"center"``: Elements are horizontally centered inside the container. - ``"right"``: Elements are aligned to the right side of the container. - ``"distribute"``: Elements are distributed evenly in the container. This increases the horizontal gap between elements to fill the width of the container. A standalone element is aligned to the left. When ``horizontal`` is ``False``, ``"distribute"`` aligns the elements the same as ``"left"``. vertical_alignment : "top", "center", "bottom", or "distribute" The vertical alignment of the elements inside the container. This can be one of the following: - ``"top"`` (default): Elements are aligned to the top of the container. - ``"center"``: Elements are vertically centered inside the container. - ``"bottom"``: Elements are aligned to the bottom of the container. - ``"distribute"``: Elements are distributed evenly in the container. This increases the vertical gap between elements to fill the height of the container. A standalone element is aligned to the top. When ``horizontal`` is ``True``, ``"distribute"`` aligns the elements the same as ``"top"``. gap : "small", "medium", "large", or None The minimum gap size between the elements inside the container. This can be one of the following: - ``"small"`` (default): 1rem gap between the elements. - ``"medium"``: 2rem gap between the elements. - ``"large"``: 4rem gap between the elements. - ``None``: No gap between the elements. The rem unit is relative to the ``theme.baseFontSize`` configuration option. The minimum gap applies to both the vertical and horizontal gaps between the elements. Elements may have larger gaps in one direction if you use a distributed horizontal alignment or fixed height. Examples -------- **Example 1: Inserting elements using ``with`` notation** You can use the ``with`` statement to insert any element into a container. >>> import streamlit as st >>> >>> with st.container(): ... st.write("This is inside the container") ... ... # You can call any Streamlit command, including custom components: ... st.bar_chart(np.random.randn(50, 3)) >>> >>> st.write("This is outside the container") .. output :: https://doc-container1.streamlit.app/ height: 520px **Example 2: Inserting elements out of order** When you create a container, its position in the app remains fixed and you can add elements to it at any time. This allows you to insert elements out of order in your app. You can also write to the container by calling commands directly on the container object. >>> import streamlit as st >>> >>> container = st.container(border=True) >>> container.write("This is inside the container") >>> st.write("This is outside the container") >>> >>> container.write("This is inside too") .. output :: https://doc-container2.streamlit.app/ height: 300px **Example 3: Grid layout with columns and containers** You can create a grid with a fixed number of elements per row by using columns and containers. >>> import streamlit as st >>> >>> row1 = st.columns(3) >>> row2 = st.columns(3) >>> >>> for col in row1 + row2: >>> tile = col.container(height=120) >>> tile.title(":balloon:") .. output :: https://doc-container3.streamlit.app/ height: 350px **Example 4: Vertically scrolling container** You can create a vertically scrolling container by setting a fixed height. >>> import streamlit as st >>> >>> long_text = "Lorem ipsum. " * 1000 >>> >>> with st.container(height=300): >>> st.markdown(long_text) .. output :: https://doc-container4.streamlit.app/ height: 400px **Example 5: Horizontal container** You can create a row of widgets using a horizontal container. Use ``horizontal_alignment`` to specify the alignment of the elements. >>> import streamlit as st >>> >>> flex = st.container(horizontal=True, horizontal_alignment="right") >>> >>> for card in range(3): >>> flex.button(f"Button {card + 1}") .. output :: https://doc-container5.streamlit.app/ height: 250px Fz st.containerTN allow_contentr,)user_keyform_id)!r BlockProto allow_emptyflex_containerr2r gap_configgap_sizerrwrap FlexContainer Direction HORIZONTAL directionrjustifyralignVERTICALr width_configCopyFromr isinstanceintr height_configrriddg_block) selfr2r3r4r5r6r7r8r9 block_protos mC:\Users\julio\OneDrive\Documentos\Trabajo\Ideas Frescas\venv\Lib\site-packages\streamlit/elements/layouts.pyr,LayoutsMixin.container=srSk l "' ,2Oe "")9E : ""--6 &&:;#$67 .2K & & +((22==  & & 02==Q1RK & & ./89K/LK & & ,.3K & & +((22;;  & & 02==O1PK & & ./89M/NK & & ,u  ))*:5*AB fc " "f&*K #  06 & & -  $ $04K & & -05K & & -d3!!**+>> import streamlit as st >>> >>> col1, col2, col3 = st.columns(3) >>> >>> with col1: ... st.header("A cat") ... st.image("https://static.streamlit.io/examples/cat.jpg") >>> >>> with col2: ... st.header("A dog") ... st.image("https://static.streamlit.io/examples/dog.jpg") >>> >>> with col3: ... st.header("An owl") ... st.image("https://static.streamlit.io/examples/owl.jpg") .. output :: https://doc-columns1.streamlit.app/ height: 620px **Example 2: Use commands as container methods** You can just call methods directly on the returned objects: >>> import streamlit as st >>> from numpy.random import default_rng as rng >>> >>> df = rng(0).standard_normal((10, 1)) >>> col1, col2 = st.columns([3, 1]) >>> >>> col1.subheader("A wide column with a chart") >>> col1.line_chart(df) >>> >>> col2.subheader("A narrow column with the data") >>> col2.write(df) .. output :: https://doc-columns2.streamlit.app/ height: 550px **Example 3: Align widgets** Use ``vertical_alignment="bottom"`` to align widgets. >>> import streamlit as st >>> >>> left, middle, right = st.columns(3, vertical_alignment="bottom") >>> >>> left.text_input("Write something") >>> middle.button("Click me", use_container_width=True) >>> right.checkbox("Check me") .. output :: https://doc-columns-bottom-widgets.streamlit.app/ height: 200px **Example 4: Use vertical alignment to create grids** Adjust vertical alignment to customize your grid layouts. >>> import streamlit as st >>> >>> vertical_alignment = st.selectbox( >>> "Vertical alignment", ["top", "center", "bottom"], index=2 >>> ) >>> >>> left, middle, right = st.columns(3, vertical_alignment=vertical_alignment) >>> left.image("https://static.streamlit.io/examples/cat.jpg") >>> middle.image("https://static.streamlit.io/examples/dog.jpg") >>> right.image("https://static.streamlit.io/examples/owl.jpg") .. output :: https://doc-columns-vertical-alignment.streamlit.app/ height: 600px **Example 5: Add borders** Add borders to your columns instead of nested containers for consistent heights. >>> import streamlit as st >>> >>> left, middle, right = st.columns(3, border=True) >>> >>> left.markdown("Lorem ipsum " * 10) >>> middle.markdown("Lorem ipsum " * 5) >>> right.markdown("Lorem ipsum ") .. output :: https://doc-columns-borders.streamlit.app/ height: 250px )rc3*# UH oS:*v M g7f)rN).0weights rV 'LayoutsMixin.columns..s#FgFaKgs)r0centerbottomz st.columns)r8 element_typec>[5nXRlURRR T5 TTURlTURlSUlU$NT)r?columnr_rBrMr8 show_borderr@)normalized_weight col_protor2rBr8vertical_alignment_mappings rV column_proto*LayoutsMixin.columns..column_protosd" I&7   #    ' ' 0 0 <2L"3I   /,2I   ($(I ! rXTr[r4)rifloatreturnr?)!rNrOlenanyrr?ColumnrTOPCENTERBOTTOMrrr!rCrErFrGrArHrDrBrMscaleAlignSTRETCHrJrrLrrRrSsum)rTspecr9r8r2r4weightsrCrlrUrow total_weightwrBrks `` @@rVrYLayoutsMixin.columnsKsT gs # #WnG w<1 #Fg#F F F13 3 $$66:: ''99@@ ''99@@  # %? ?8#5)   \2[ &   !l  $ $ . . 9 9 "",+/ ""'""--66zB+, ""(+5+C+C+I+I+Q+Q ""(U#  ))*:*GHggnn[)7| DKLGq <(89:GLLLs"H&tabsrnc^^U(d [S5e[SU55(a [S5eSSjm[5nURR 5 [ U5 UR R[U55 URRU5m[UU4SjU55$)u Insert containers separated into tabs. Inserts a number of multi-element containers as tabs. Tabs are a navigational element that allows users to easily move between groups of related content. To add elements to the returned containers, you can use the ``with`` notation (preferred) or just call methods directly on the returned object. See examples below. .. note:: All content within every tab is computed and sent to the frontend, regardless of which tab is selected. Tabs do not currently support conditional rendering. If you have a slow-loading tab, consider using a widget like ``st.segmented_control`` to conditionally render content instead. Parameters ---------- tabs : list of str Creates a tab for each string in the list. The first tab is selected by default. The string is used as the name of the tab and can optionally contain GitHub-flavored Markdown of the following types: Bold, Italics, Strikethroughs, Inline Code, Links, and Images. Images display like icons, with a max height equal to the font height. Unsupported Markdown elements are unwrapped so only their children (text contents) render. Display unsupported elements as literal characters by backslash-escaping them. E.g., ``"1\. Not an ordered list"``. See the ``body`` parameter of |st.markdown|_ for additional, supported Markdown directives. .. |st.markdown| replace:: ``st.markdown`` .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown width : "stretch" or int The width of the tab container. This can be one of the following: - ``"stretch"`` (default): The width of the container matches the width of the parent container. - An integer specifying the width in pixels: The container has a fixed width. If the specified width is greater than the width of the parent container, the width of the container matches the width of the parent container. Returns ------- list of containers A list of container objects. Examples -------- You can use the ``with`` notation to insert any element into a tab: >>> import streamlit as st >>> >>> tab1, tab2, tab3 = st.tabs(["Cat", "Dog", "Owl"]) >>> >>> with tab1: ... st.header("A cat") ... st.image("https://static.streamlit.io/examples/cat.jpg", width=200) >>> with tab2: ... st.header("A dog") ... st.image("https://static.streamlit.io/examples/dog.jpg", width=200) >>> with tab3: ... st.header("An owl") ... st.image("https://static.streamlit.io/examples/owl.jpg", width=200) .. output :: https://doc-tabs1.streamlit.app/ height: 620px Or you can just call methods directly on the returned objects: >>> import streamlit as st >>> from numpy.random import default_rng as rng >>> >>> df = rng(0).standard_normal((10, 1)) >>> >>> tab1, tab2 = st.tabs(["📈 Chart", "🗃 Data"]) >>> >>> tab1.subheader("A tab with a chart") >>> tab1.line_chart(df) >>> >>> tab2.subheader("A tab with the data") >>> tab2.write(df) .. output :: https://doc-tabs2.streamlit.app/ height: 700px zBThe input argument to st.tabs must contain at least one tab label.c3L# UHn[U[5(+v M g7fN)rNstr)r^tabs rVr`$LayoutsMixin.tabs..s84C:c3'''4s"$zBThe tabs input list to st.tabs is only allowed to contain strings.cH[5nXRlSUlU$rf)r?rlabelr@)r tab_protos rVr$LayoutsMixin.tabs..tab_protos!" I"'MM $(I ! rXc3R># UHnTRT"U55v M g7fr)rS)r^ tab_label tab_containerrs rVr`rs&VQUI])))I*>??QUs$')rrrpr?) rrrr?r SetInParentrrLrMrrRrStuple)rTrr4rUrrs @@rVrLayoutsMixin.tabs,sL'T  848 8 8'T   !l !!--/u  ))*:5*AB{3 VQUVVVrXexpander)iconr4cnUc [S5e[R"5nX%lXlUb[ U5Ul[5nSUlURRU5 [U5 URR[U55 URRUS9$)uInsert a multi-element container that can be expanded/collapsed. Inserts a container into your app that can be used to hold multiple elements and can be expanded or collapsed by the user. When collapsed, all that is visible is the provided label. To add elements to the returned container, you can use the ``with`` notation (preferred) or just call methods directly on the returned object. See examples below. .. note:: All content within the expander is computed and sent to the frontend, even if the expander is closed. To follow best design practices and maintain a good appearance on all screen sizes, don't nest expanders. Parameters ---------- label : str A string to use as the header for the expander. The label can optionally contain GitHub-flavored Markdown of the following types: Bold, Italics, Strikethroughs, Inline Code, Links, and Images. Images display like icons, with a max height equal to the font height. Unsupported Markdown elements are unwrapped so only their children (text contents) render. Display unsupported elements as literal characters by backslash-escaping them. E.g., ``"1\. Not an ordered list"``. See the ``body`` parameter of |st.markdown|_ for additional, supported Markdown directives. .. |st.markdown| replace:: ``st.markdown`` .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown expanded : bool If True, initializes the expander in "expanded" state. Defaults to False (collapsed). icon : str, None An optional emoji or icon to display next to the expander label. If ``icon`` is ``None`` (default), no icon is displayed. If ``icon`` is a string, the following options are valid: - A single-character emoji. For example, you can set ``icon="🚨"`` or ``icon="🔥"``. Emoji short codes are not supported. - An icon from the Material Symbols library (rounded style) in the format ``":material/icon_name:"`` where "icon_name" is the name of the icon in snake case. For example, ``icon=":material/thumb_up:"`` will display the Thumb Up icon. Find additional icons in the `Material Symbols \ `_ font library. width : "stretch" or int The width of the expander container. This can be one of the following: - ``"stretch"`` (default): The width of the container matches the width of the parent container. - An integer specifying the width in pixels: The container has a fixed width. If the specified width is greater than the width of the parent container, the width of the container matches the width of the parent container. Examples -------- You can use the ``with`` notation to insert any element into an expander >>> import streamlit as st >>> >>> st.bar_chart({"data": [1, 5, 2, 6, 2, 1]}) >>> >>> with st.expander("See explanation"): ... st.write(''' ... The chart above shows some numbers I picked for you. ... I rolled actual dice for these, so they're *guaranteed* to ... be random. ... ''') ... st.image("https://static.streamlit.io/examples/dice.jpg") .. output :: https://doc-expander.streamlit.app/ height: 750px Or you can just call methods directly on the returned objects: >>> import streamlit as st >>> >>> st.bar_chart({"data": [1, 5, 2, 6, 2, 1]}) >>> >>> expander = st.expander("See explanation") >>> expander.write(''' ... The chart above shows some numbers I picked for you. ... I rolled actual dice for these, so they're *guaranteed* to ... be random. ... ''') >>> expander.image("https://static.streamlit.io/examples/dice.jpg") .. output :: https://doc-expander.streamlit.app/ height: 750px z#A label is required for an expanderTrU)rr? Expandableexpandedrr#rr@ expandablerMrrLrrRrS)rTrrrr4expandable_protorUs rVrLayoutsMixin.expandersf ='(MN N%002$,!!&  $:4$@  ! l "& ''(89u  ))*:5*ABww~~+~66rXpopover)helprdisableduse_container_widthr4cUc [S5eUb U(aSOSn[R"5nXlXGlU(a[ U5UlUb[U5Ul[5nSUl URRU5 [USS9 URR[U55 URR!US9$)uiInsert a popover container. Inserts a multi-element container as a popover. It consists of a button-like element and a container that opens when the button is clicked. Opening and closing the popover will not trigger a rerun. Interacting with widgets inside of an open popover will rerun the app while keeping the popover open. Clicking outside of the popover will close it. To add elements to the returned container, you can use the "with" notation (preferred) or just call methods directly on the returned object. See examples below. .. note:: To follow best design practices, don't nest popovers. Parameters ---------- label : str The label of the button that opens the popover container. The label can optionally contain GitHub-flavored Markdown of the following types: Bold, Italics, Strikethroughs, Inline Code, Links, and Images. Images display like icons, with a max height equal to the font height. Unsupported Markdown elements are unwrapped so only their children (text contents) render. Display unsupported elements as literal characters by backslash-escaping them. E.g., ``"1\. Not an ordered list"``. See the ``body`` parameter of |st.markdown|_ for additional, supported Markdown directives. .. |st.markdown| replace:: ``st.markdown`` .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown help : str or None A tooltip that gets displayed when the popover button is hovered over. If this is ``None`` (default), no tooltip is displayed. The tooltip can optionally contain GitHub-flavored Markdown, including the Markdown directives described in the ``body`` parameter of ``st.markdown``. icon : str An optional emoji or icon to display next to the button label. If ``icon`` is ``None`` (default), no icon is displayed. If ``icon`` is a string, the following options are valid: - A single-character emoji. For example, you can set ``icon="🚨"`` or ``icon="🔥"``. Emoji short codes are not supported. - An icon from the Material Symbols library (rounded style) in the format ``":material/icon_name:"`` where "icon_name" is the name of the icon in snake case. For example, ``icon=":material/thumb_up:"`` will display the Thumb Up icon. Find additional icons in the `Material Symbols \ `_ font library. disabled : bool An optional boolean that disables the popover button if set to ``True``. The default is ``False``. use_container_width : bool Whether to expand the button's width to fill its parent container. If ``use_container_width`` is ``False`` (default), Streamlit sizes the button to fit its content. If ``use_container_width`` is ``True``, the width of the button matches its parent container. In both cases, if the content of the button is wider than the parent container, the content will line wrap. The popover container's minimum width matches the width of its button. The popover container may be wider than its button to fit the container's content. width : int, "stretch", or "content" The width of the button. This can be one of the following: - ``"content"`` (default): The width of the button matches the width of its content, but doesn't exceed the width of the parent container. - ``"stretch"``: The width of the button matches the width of the parent container. - An integer specifying the width in pixels: The button has a fixed width. If the specified width is greater than the width of the parent container, the width of the button matches the width of the parent container. The popover container's minimum width matches the width of its button. The popover container may be wider than its button to fit the container's contents. .. deprecated:: ``use_container_width`` is deprecated and will be removed in a future release. For ``use_container_width=True``, use ``width="stretch"``. For ``use_container_width=False``, use ``width="content"``. Examples -------- You can use the ``with`` notation to insert any element into a popover: >>> import streamlit as st >>> >>> with st.popover("Open popover"): >>> st.markdown("Hello World 👋") >>> name = st.text_input("What's your name?") >>> >>> st.write("Your name:", name) .. output :: https://doc-popover.streamlit.app/ height: 400px Or you can just call methods directly on the returned objects: >>> import streamlit as st >>> >>> popover = st.popover("Filter items") >>> red = popover.checkbox("Show red items.", True) >>> blue = popover.checkbox("Show blue items.", True) >>> >>> if red: ... st.write(":red[This is a red item.]") >>> if blue: ... st.write(":blue[This is a blue item.]") .. output :: https://doc-popover2.streamlit.app/ height: 400px z!A label is required for a popoverr-r.Tr;r)rr?Popoverrrrrr#rr@rrMrrLrrRrS) rTrrrrrr4 popover_protorUs rVrLayoutsMixin.popover-sd ='(KL L  *!4I)E"**, #!) !$TM   !7!=M  l "& $$]3uD1  ))*:5*ABww~~+~66rXstatusrunningrstater4c\[5RRURXX4S9$)asInsert a status container to display output from long-running tasks. Inserts a container into your app that is typically used to show the status and details of a process or task. The container can hold multiple elements and can be expanded or collapsed by the user similar to ``st.expander``. When collapsed, all that is visible is the status icon and label. The label, state, and expanded state can all be updated by calling ``.update()`` on the returned object. To add elements to the returned container, you can use ``with`` notation (preferred) or just call methods directly on the returned object. By default, ``st.status()`` initializes in the "running" state. When called using ``with`` notation, it automatically updates to the "complete" state at the end of the "with" block. See examples below for more details. .. note:: All content within the status container is computed and sent to the frontend, even if the status container is closed. To follow best design practices and maintain a good appearance on all screen sizes, don't nest status containers. Parameters ---------- label : str The initial label of the status container. The label can optionally contain GitHub-flavored Markdown of the following types: Bold, Italics, Strikethroughs, Inline Code, Links, and Images. Images display like icons, with a max height equal to the font height. Unsupported Markdown elements are unwrapped so only their children (text contents) render. Display unsupported elements as literal characters by backslash-escaping them. E.g., ``"1\. Not an ordered list"``. See the ``body`` parameter of |st.markdown|_ for additional, supported Markdown directives. .. |st.markdown| replace:: ``st.markdown`` .. _st.markdown: https://docs.streamlit.io/develop/api-reference/text/st.markdown expanded : bool If True, initializes the status container in "expanded" state. Defaults to False (collapsed). state : "running", "complete", or "error" The initial state of the status container which determines which icon is shown: - ``running`` (default): A spinner icon is shown. - ``complete``: A checkmark icon is shown. - ``error``: An error icon is shown. width : "stretch" or int The width of the status container. This can be one of the following: - ``"stretch"`` (default): The width of the container matches the width of the parent container. - An integer specifying the width in pixels: The container has a fixed width. If the specified width is greater than the width of the parent container, the width of the container matches the width of the parent container. Returns ------- StatusContainer A mutable status container that can hold multiple elements. The label, state, and expanded state can be updated after creation via ``.update()``. Examples -------- You can use the ``with`` notation to insert any element into an status container: >>> import time >>> import streamlit as st >>> >>> with st.status("Downloading data..."): ... st.write("Searching for data...") ... time.sleep(2) ... st.write("Found URL.") ... time.sleep(1) ... st.write("Downloading data...") ... time.sleep(1) >>> >>> st.button("Rerun") .. output :: https://doc-status.streamlit.app/ height: 300px You can also use ``.update()`` on the container to change the label, state, or expanded state: >>> import time >>> import streamlit as st >>> >>> with st.status("Downloading data...", expanded=True) as status: ... st.write("Searching for data...") ... time.sleep(2) ... st.write("Found URL.") ... time.sleep(1) ... st.write("Downloading data...") ... time.sleep(1) ... status.update( ... label="Download complete!", state="complete", expanded=False ... ) >>> >>> st.button("Rerun") .. output :: https://doc-status-update.streamlit.app/ height: 300px r)r status_container_cls_createrR)rTrrrr4s rVrLayoutsMixin.statuss2x)*??GG GGUUH  rXTignore dismissibler4 on_dismissc\[5RRURXX4S9$)zInserts the dialog container. Marked as internal because it is used by the dialog_decorator and is not supposed to be used directly. The dialog_decorator also has a more descriptive docstring since it is user-facing. r)r dialog_container_clsrrR)rTtitlerr4rs rV_dialogLayoutsMixin._dialogVs1)*??GG GGU5H  rXc[SU5$)zGet our DeltaGenerator.r$)r)rTs rVrRLayoutsMixin.dggs$d++rXr])r2 bool | Noner3z Key | Noner4rr5r r6boolr7r r8rr9 Gap | Nonerpr$) r{r(r9rr8z"Literal['top', 'center', 'bottom']r2rr4rrpzlist[DeltaGenerator])rz Sequence[str]r4rrpzSequence[DeltaGenerator])F) rrrrr str | Noner4rrpr$)rrrrrrrrrrr4rrpr$) rrrrrz'Literal['running', 'complete', 'error']r4rrpr&) rrrrr4zLiteral['small', 'large']rz+Literal['ignore', 'rerun'] | WidgetCallbackrpr%)rpr$)__name__ __module__ __qualname____firstlineno__r"r,rYrrrrrpropertyrR__static_attributes__r]rXrVr*r*<sK #%." 4:05!K+K+ K+ # K+  K+K+2K+.K+K+ K+!K+ZI "AF%.^M^M ^M ? ^M  ^M#^M ^M^M@F &/ zWzW# zW " zWzWxJA7  %. A7A7A7  A7 # A7 A7 A7FI  +/ f7f7 f7  f7  f7)f7f7 f7f7PH 9B%. } }  } 7 } # }  } } F!+2BJ     )  @    ",,rXr*N); __future__rcollections.abcrtypingrrrrtyping_extensionsr $streamlit.delta_generator_singletonsr #streamlit.elements.lib.layout_utilsr r r rrrrrrrrrrrrstreamlit.elements.lib.utilsrrrstreamlit.errorsrrrstreamlit.proto.Block_pb2r r?streamlit.proto.GapSize_pb2r!streamlit.runtime.metrics_utilr"streamlit.string_utilr#streamlit.delta_generatorr$streamlit.elements.lib.dialogr%/streamlit.elements.lib.mutable_status_containerr&streamlit.runtime.stater'rOror(__annotations__r*r]rXrVrs#$66'J"VU :19884O6C%U *;!<<=)=n,n,rX