docstr: 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 "with" notation
  (preferred) or just call methods directly on the returned object. See
  examples below.
  
  .. warning::
      All the content of every tab is always sent to and rendered on the frontend.
      Conditional rendering is currently not supported.
  
  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 Markdown,
      supporting the following elements: Bold, Italics, Strikethroughs, Inline Code,
      Emojis, and Links.
  
      This also supports:
  
      * Emoji shortcodes, such as ``:+1:``  and ``:sunglasses:``.
        For a list of all supported codes,
        see https://share.streamlit.io/streamlit/emoji-shortcodes.
  
      * LaTeX expressions, by wrapping them in "$" or "$$" (the "$$"
        must be on their own lines). Supported LaTeX functions are listed
        at https://katex.org/docs/supported.html.
  
      * Colored text, using the syntax ``:color[text to be colored]``,
        where ``color`` needs to be replaced with any of the following
        supported colors: blue, green, orange, red, violet, gray/grey, rainbow.
  
      Unsupported 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``.
  
  Returns
  -------
  list of containers
      A list of container objects.
  
  Examples
  --------
  You can use `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 in the returned objects:
  
  >>> import streamlit as st
  >>> import numpy as np
  >>>
  >>> tab1, tab2 = st.tabs(["📈 Chart", "🗃 Data"])
  >>> data = np.random.randn(10, 1)
  >>>
  >>> tab1.subheader("A tab with a chart")
  >>> tab1.line_chart(data)
  >>>
  >>> tab2.subheader("A tab with the data")
  >>> tab2.write(data)
  
  
  .. output ::
      https://doc-tabs2.streamlit.app/
      height: 700px
code: def tabs(self, tabs: Sequence[str]) -> Sequence["DeltaGenerator"]:
      r"""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 "with" notation
      (preferred) or just call methods directly on the returned object. See
      examples below.
  
      .. warning::
          All the content of every tab is always sent to and rendered on the frontend.
          Conditional rendering is currently not supported.
  
      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 Markdown,
          supporting the following elements: Bold, Italics, Strikethroughs, Inline Code,
          Emojis, and Links.
  
          This also supports:
  
          * Emoji shortcodes, such as ``:+1:``  and ``:sunglasses:``.
            For a list of all supported codes,
            see https://share.streamlit.io/streamlit/emoji-shortcodes.
  
          * LaTeX expressions, by wrapping them in "$" or "$$" (the "$$"
            must be on their own lines). Supported LaTeX functions are listed
            at https://katex.org/docs/supported.html.
  
          * Colored text, using the syntax ``:color[text to be colored]``,
            where ``color`` needs to be replaced with any of the following
            supported colors: blue, green, orange, red, violet, gray/grey, rainbow.
  
          Unsupported 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``.
  
      Returns
      -------
      list of containers
          A list of container objects.
  
      Examples
      --------
      You can use `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 in the returned objects:
  
      >>> import streamlit as st
      >>> import numpy as np
      >>>
      >>> tab1, tab2 = st.tabs(["📈 Chart", "🗃 Data"])
      >>> data = np.random.randn(10, 1)
      >>>
      >>> tab1.subheader("A tab with a chart")
      >>> tab1.line_chart(data)
      >>>
      >>> tab2.subheader("A tab with the data")
      >>> tab2.write(data)
  
  
      .. output ::
          https://doc-tabs2.streamlit.app/
          height: 700px
  
      """
      if not tabs:
          raise StreamlitAPIException(
              "The input argument to st.tabs must contain at least one tab label."
          )
  
      if any(isinstance(tab, str) == False for tab in tabs):
          raise StreamlitAPIException(
              "The tabs input list to st.tabs is only allowed to contain strings."
          )
  
      def tab_proto(label: str) -> BlockProto:
          tab_proto = BlockProto()
          tab_proto.tab.label = label
          tab_proto.allow_empty = True
          return tab_proto
  
      block_proto = BlockProto()
      block_proto.tab_container.SetInParent()
      tab_container = self.dg._block(block_proto)
      return tuple(
          tab_container._block(tab_proto(tab_label))
          for tab_label in tabs
      )
  
file_path: streamlit/lib/streamlit/elements/layouts.py
imports: from __future__ import annotations
  from typing import TYPE_CHECKING, List, Literal, Optional, Sequence, Union, cast
  from streamlit.errors import StreamlitAPIException
  from streamlit.proto.Block_pb2 import Block
  from streamlit.runtime.metrics_util import gather_metrics
label_desc: Use image node_id 3 for calling the LayoutsMixin obj's underlying member method code with example usage: obj.tabs(tabs) and returns: tuple, tab_proto