streamlit 1.48.1__py3-none-any.whl → 1.49.0__py3-none-any.whl

streamlit/__init__.py

@@ -93,10 +93,7 @@ _event = _dg_singleton._event_dg
 _bottom = _dg_singleton._bottom_dg
 
 
-from streamlit.elements.dialog_decorator import (
-    dialog_decorator as _dialog_decorator,
-    experimental_dialog_decorator as _experimental_dialog_decorator,
-)
+from streamlit.elements.dialog_decorator import dialog_decorator as _dialog_decorator
 from streamlit.runtime.caching import (
     cache_resource as _cache_resource,
     cache_data as _cache_data,
@@ -105,10 +102,7 @@ from streamlit.runtime.caching import (
 from streamlit.runtime.connection_factory import (
     connection_factory as _connection,
 )
-from streamlit.runtime.fragment import (
-    experimental_fragment as _experimental_fragment,
-    fragment as _fragment,
-)
+from streamlit.runtime.fragment import fragment as _fragment
 from streamlit.runtime.metrics_util import gather_metrics as _gather_metrics
 from streamlit.runtime.secrets import secrets_singleton as _secrets_singleton
 from streamlit.runtime.context import ContextProxy as _ContextProxy
@@ -212,6 +206,7 @@ metric = _main.metric
 multiselect = _main.multiselect
 number_input = _main.number_input
 page_link = _main.page_link
+pdf = _main.pdf
 pills = _main.pills
 plotly_chart = _main.plotly_chart
 popover = _main.popover
@@ -283,8 +278,6 @@ logout = _logout
 user = _UserInfoProxy()
 
 # Experimental APIs
-experimental_dialog = _experimental_dialog_decorator
-experimental_fragment = _experimental_fragment
 experimental_user = _DeprecatedUserInfoProxy()
 
 _EXPERIMENTAL_QUERY_PARAMS_DEPRECATE_MSG = (

streamlit/commands/logo.py

@@ -19,7 +19,8 @@ from __future__ import annotations
 from typing import Literal
 
 from streamlit import url_util
-from streamlit.elements.lib.image_utils import AtomicImage, WidthBehavior, image_to_url
+from streamlit.elements.lib.image_utils import AtomicImage, image_to_url
+from streamlit.elements.lib.layout_utils import LayoutConfig
 from streamlit.errors import StreamlitAPIException
 from streamlit.proto.ForwardMsg_pb2 import ForwardMsg
 from streamlit.runtime.metrics_util import gather_metrics
@@ -142,7 +143,7 @@ def logo(
     try:
         image_url = image_to_url(
             image,
-            width=WidthBehavior.AUTO,
+            layout_config=LayoutConfig(width="content"),
             clamp=False,
             channels="RGB",
             output_format="auto",
@@ -166,7 +167,7 @@ def logo(
         try:
             icon_image_url = image_to_url(
                 icon_image,
-                width=WidthBehavior.AUTO,
+                layout_config=LayoutConfig(width="content"),
                 clamp=False,
                 channels="RGB",
                 output_format="auto",

streamlit/commands/navigation.py

@@ -316,7 +316,7 @@ def _navigation(
     else:
         nav_sections = {
             section: [convert_to_streamlit_page(p) for p in section_pages]
-            for section, section_pages in pages.items()
+            for section, section_pages in pages.items()  # ty: ignore[possibly-unbound-attribute]
         }
     page_list = pages_from_nav_sections(nav_sections)
 

streamlit/commands/page_config.py

@@ -23,6 +23,7 @@ from typing import TYPE_CHECKING, Any, Final, Literal, Union, cast
 from typing_extensions import TypeAlias
 
 from streamlit.elements.lib.image_utils import AtomicImage, image_to_url
+from streamlit.elements.lib.layout_utils import LayoutConfig
 from streamlit.errors import (
     StreamlitInvalidMenuItemKeyError,
     StreamlitInvalidPageLayoutError,
@@ -91,7 +92,9 @@ def _get_favicon_string(page_icon: PageIcon) -> str:
     try:
         return image_to_url(
             page_icon,
-            width=-1,  # Always use full width for favicons
+            layout_config=LayoutConfig(
+                width="stretch"
+            ),  # Always use full width for favicons
             clamp=False,
             channels="RGB",
             output_format="auto",

streamlit/components/v1/custom_component.py

@@ -194,7 +194,7 @@ And if you're using Streamlit Cloud, add "pyarrow" to your requirements.txt."""
                 computed_id = compute_and_register_element_id(
                     "component_instance",
                     user_key=key,
-                    form_id=current_form_id(dg),
+                    dg=dg,
                     name=self.name,
                     url=self.url,
                     json_args=serialized_json_args,
@@ -204,7 +204,7 @@ And if you're using Streamlit Cloud, add "pyarrow" to your requirements.txt."""
                 computed_id = compute_and_register_element_id(
                     "component_instance",
                     user_key=key,
-                    form_id=current_form_id(dg),
+                    dg=dg,
                     name=self.name,
                     url=self.url,
                 )

streamlit/config.py

@@ -17,6 +17,7 @@
 from __future__ import annotations
 
 import copy
+import json
 import logging
 import os
 import secrets
@@ -960,12 +961,39 @@ _create_option(
 
         The server may choose to clean up session state, uploaded files, etc
         for a given session with no active websocket connection at any point
-        after this time has passed.
+        after this time has passed. If you are using load balancing or
+        replication in your deployment, you must enable session stickiness
+        in your proxy to guarantee reconnection to the existing session. For
+        more information, see https://docs.streamlit.io/replication.
     """,
     default_val=120,
     type_=int,
 )
 
+_create_option(
+    "server.trustedUserHeaders",
+    description="""
+        HTTP headers to embed in st.user.
+
+        Configures HTTP headers whose values, on websocket connect, will be saved in
+        st.user. Each key is the header name to map, and each value is the key in
+        st.user to save the value under. If the configured header occurs multiple times
+        in the request, the first value will be used. Multiple headers may not point to
+        the same user key, and an error will be thrown on initialization if this is
+        done.
+
+        If configured using an environment variable or CLI option, it should be a
+        single JSON-formatted dict of string-to-string.
+
+        Note: This is an experimental API subject to change.
+    """,
+    default_val={},
+    # This is used by click. We accept a JSON string, so this is a str.
+    type_=str,
+    # Hide until API is finalized.
+    visibility="hidden",
+)
+
 # Config Section: Browser #
 
 _create_section("browser", "Configuration of non-UI browser options.")
@@ -1987,6 +2015,56 @@ def _set_development_mode() -> None:
     development.is_development_mode = get_option("global.developmentMode")
 
 
+def _parse_trusted_user_headers() -> None:
+    """Convert string-valued server.trustedUserHeaders to a dict.
+
+    If server.trustedUserHeaders is configured from an environment variable or from
+    the CLI, it will be a JSON string. Parse this and set the value to the resulting
+    dict, after validation.
+    """
+    options = get_config_options()
+    trusted_user_headers = options["server.trustedUserHeaders"]
+    if isinstance(trusted_user_headers.value, str):
+        try:
+            parsed_value = json.loads(trusted_user_headers.value)
+            # Validate that this is an object with string values.
+            if not isinstance(parsed_value, dict):
+                # Config validation is using RuntimeError deliberately; ignore warning
+                # about making this TypeError.
+                # ruff: noqa: TRY004
+                raise RuntimeError("server.trustedUserHeaders JSON must be an object")
+            for json_key, json_value in parsed_value.items():
+                if not isinstance(json_value, str):
+                    raise RuntimeError(
+                        "server.trustedUserHeaders JSON must only have string values. "
+                        f'got bad value for key "{json_key}": {json_value}'
+                    )
+            set_option(
+                "server.trustedUserHeaders",
+                parsed_value,
+                where_defined=trusted_user_headers.where_defined,
+            )
+        except json.JSONDecodeError as jde:
+            raise RuntimeError(
+                f"bad JSON value for server.trustedUserHeaders: {jde.msg}"
+            )
+
+    # Fetch the latest value, since we might've updated it from JSON.
+    final_config_value = options["server.trustedUserHeaders"].value
+    # Ensure no user keys are duplicated.
+    values = set()
+    bad_keys = []
+    for user_key in final_config_value.values():
+        if user_key in values:
+            bad_keys.append(user_key)
+        values.add(user_key)
+
+    if bad_keys:
+        raise RuntimeError(
+            f"server.trustedUserHeaders had multiple mappings for user key(s) {bad_keys}"
+        )
+
+
 def on_config_parsed(
     func: Callable[[], None], force_connect: bool = False, lock: bool = False
 ) -> Callable[[], None]:
@@ -2046,3 +2124,6 @@ def on_config_parsed(
 # may edit config options based on the values of other config options.
 on_config_parsed(_check_conflicts, lock=True)
 on_config_parsed(_set_development_mode)
+# Update server.trustedUserHeaders from any JSON string that was set. Take out the
+# lock, since this is mutating the config.
+on_config_parsed(_parse_trusted_user_headers, lock=True)

streamlit/connections/snowflake_connection.py

@@ -73,7 +73,9 @@ class SnowflakeConnection(BaseConnection["InternalSnowflakeConnection"]):
         must be installed in your environment to use this connection. You can
         install it as an extra with Streamlit:
 
-        >>> pip install streamlit[snowflake]
+        .. code-block:: shell
+
+           pip install streamlit[snowflake]
 
     .. Important::
         Account identifiers must be of the form ``<orgname>-<account_name>``

streamlit/delta_generator.py

@@ -71,6 +71,7 @@ from streamlit.elements.map import MapMixin
 from streamlit.elements.markdown import MarkdownMixin
 from streamlit.elements.media import MediaMixin
 from streamlit.elements.metric import MetricMixin
+from streamlit.elements.pdf import PdfMixin
 from streamlit.elements.plotly_chart import PlotlyMixin
 from streamlit.elements.progress import ProgressMixin
 from streamlit.elements.pyplot import PyplotMixin
@@ -196,6 +197,7 @@ class DeltaGenerator(
     MetricMixin,
     MultiSelectMixin,
     NumberInputMixin,
+    PdfMixin,
     PlotlyMixin,
     ProgressMixin,
     PydeckMixin,
@@ -533,6 +535,7 @@ class DeltaGenerator(
             invoked_dg_id=self.id,
             used_dg_id=dg.id,
             returned_dg_id=output_dg.id,
+            layout_config=layout_config,
         )
 
         return output_dg

streamlit/elements/arrow.py

@@ -29,6 +29,10 @@ from typing import (
 from typing_extensions import TypeAlias
 
 from streamlit import dataframe_util
+from streamlit.deprecation_util import (
+    make_deprecated_name_warning,
+    show_deprecation_warning,
+)
 from streamlit.elements.lib.column_config_utils import (
     INDEX_IDENTIFIER,
     ColumnConfigMappingInput,
@@ -40,6 +44,9 @@ from streamlit.elements.lib.column_config_utils import (
 from streamlit.elements.lib.form_utils import current_form_id
 from streamlit.elements.lib.layout_utils import (
     LayoutConfig,
+    Width,
+    validate_height,
+    validate_width,
 )
 from streamlit.elements.lib.pandas_styler_utils import marshall_styler
 from streamlit.elements.lib.policies import check_widget_policies
@@ -67,13 +74,20 @@ if TYPE_CHECKING:
 
 
 SelectionMode: TypeAlias = Literal[
-    "single-row", "multi-row", "single-column", "multi-column"
+    "single-row",
+    "multi-row",
+    "single-column",
+    "multi-column",
+    "single-cell",
+    "multi-cell",
 ]
 _SELECTION_MODES: Final[set[SelectionMode]] = {
     "single-row",
     "multi-row",
     "single-column",
     "multi-column",
+    "single-cell",
+    "multi-cell",
 }
 
 
@@ -100,12 +114,18 @@ class DataframeSelectionState(TypedDict, total=False):
         or ``.iat[]``.
     columns : list[str]
         The selected columns, identified by their names.
+    cells : list[tuple[int, str]]
+        The selected cells, provided as a tuple of row integer position
+        and column name. For example, the first cell in a column named "col 1"
+        is represented as ``(0, "col 1")``. Cells within index columns are not
+        returned.
 
     Example
     -------
     The following example has multi-row and multi-column selections enabled.
-    Try selecting some rows. To select multiple columns, hold ``Ctrl`` while
-    selecting columns. Hold ``Shift`` to select a range of columns.
+    Try selecting some rows. To select multiple columns, hold ``CMD`` (macOS)
+    or ``Ctrl`` (Windows) while selecting columns. Hold ``Shift`` to select a
+    range of columns.
 
     >>> import pandas as pd
     >>> import streamlit as st
@@ -119,7 +139,7 @@ class DataframeSelectionState(TypedDict, total=False):
     ...     df,
     ...     key="data",
     ...     on_select="rerun",
-    ...     selection_mode=["multi-row", "multi-column"],
+    ...     selection_mode=["multi-row", "multi-column", "multi-cell"],
     ... )
     >>>
     >>> event.selection
@@ -132,6 +152,7 @@ class DataframeSelectionState(TypedDict, total=False):
 
     rows: list[int]
     columns: list[str]
+    cells: list[tuple[int, str]]
 
 
 class DataframeState(TypedDict, total=False):
@@ -167,6 +188,7 @@ class DataframeSelectionSerde:
             "selection": {
                 "rows": [],
                 "columns": [],
+                "cells": [],
             },
         }
         selection_state: DataframeState = (
@@ -176,10 +198,27 @@ class DataframeSelectionSerde:
         if "selection" not in selection_state:
             selection_state = empty_selection_state
 
+        if "rows" not in selection_state["selection"]:
+            selection_state["selection"]["rows"] = []
+
+        if "columns" not in selection_state["selection"]:
+            selection_state["selection"]["columns"] = []
+
+        if "cells" not in selection_state["selection"]:
+            selection_state["selection"]["cells"] = []
+        else:
+            # Explicitly convert all cells to a tuple (from list).
+            # This is necessary since there isn't a concept of tuples in JSON
+            # The format that the data is transferred to the backend.
+            selection_state["selection"]["cells"] = [
+                tuple(cell)  # type: ignore
+                for cell in selection_state["selection"]["cells"]
+            ]
+
         return cast("DataframeState", AttributeDictionary(selection_state))
 
-    def serialize(self, editing_state: DataframeState) -> str:
-        return json.dumps(editing_state, default=str)
+    def serialize(self, state: DataframeState) -> str:
+        return json.dumps(state)
 
 
 def parse_selection_mode(
@@ -209,6 +248,11 @@ def parse_selection_mode(
             "Only one of `single-column` or `multi-column` can be selected as selection mode."
         )
 
+    if selection_mode_set.issuperset({"single-cell", "multi-cell"}):
+        raise StreamlitAPIException(
+            "Only one of `single-cell` or `multi-cell` can be selected as selection mode."
+        )
+
     parsed_selection_modes = []
     for mode in selection_mode_set:
         if mode == "single-row":
@@ -219,6 +263,10 @@ def parse_selection_mode(
             parsed_selection_modes.append(ArrowProto.SelectionMode.SINGLE_COLUMN)
         elif mode == "multi-column":
             parsed_selection_modes.append(ArrowProto.SelectionMode.MULTI_COLUMN)
+        elif mode == "single-cell":
+            parsed_selection_modes.append(ArrowProto.SelectionMode.SINGLE_CELL)
+        elif mode == "multi-cell":
+            parsed_selection_modes.append(ArrowProto.SelectionMode.MULTI_CELL)
     return set(parsed_selection_modes)
 
 
@@ -227,8 +275,8 @@ class ArrowMixin:
     def dataframe(
         self,
         data: Data = None,
-        width: int | None = None,
-        height: int | None = None,
+        width: Width = "stretch",
+        height: int | Literal["auto"] = "auto",
         *,
         use_container_width: bool | None = None,
         hide_index: bool | None = None,
@@ -244,8 +292,8 @@ class ArrowMixin:
     def dataframe(
         self,
         data: Data = None,
-        width: int | None = None,
-        height: int | None = None,
+        width: Width = "stretch",
+        height: int | Literal["auto"] = "auto",
         *,
         use_container_width: bool | None = None,
         hide_index: bool | None = None,
@@ -261,8 +309,8 @@ class ArrowMixin:
     def dataframe(
         self,
         data: Data = None,
-        width: int | None = None,
-        height: int | None = None,
+        width: Width = "stretch",
+        height: int | Literal["auto"] = "auto",
         *,
         use_container_width: bool | None = None,
         hide_index: bool | None = None,
@@ -318,18 +366,28 @@ class ArrowMixin:
 
             If ``data`` is ``None``, Streamlit renders an empty table.
 
-        width : int or None
-            Desired width of the dataframe expressed in pixels. If ``width`` is
-            ``None`` (default), Streamlit sets the dataframe width to fit its
-            contents up to the width of the parent container. If ``width`` is
-            greater than the width of the parent container, Streamlit sets the
-            dataframe width to match the width of the parent container.
+        width : "stretch", "content", or int
+            The width of the dataframe element. This can be one of the following:
+
+            - ``"stretch"`` (default): The width of the element matches the
+              width of the parent container.
+            - ``"content"``: The width of the element matches the width of its
+              content, but doesn't exceed the width of the parent container.
+            - An integer specifying the width in pixels: The element has a
+              fixed width. If the specified width is greater than the width of
+              the parent container, the width of the element matches the width
+              of the parent container.
+
+        height : int or "auto"
+            The height of the dataframe element. This can be one of the following:
+
+            - ``"auto"`` (default): Streamlit sets the height to show at most
+              ten rows.
+            - An integer specifying the height in pixels: The element has a
+              fixed height.
 
-        height : int or None
-            Desired height of the dataframe expressed in pixels. If ``height``
-            is ``None`` (default), Streamlit sets the height to show at most
-            ten rows. Vertical scrolling within the dataframe element is
-            enabled when the height does not accommodate all rows.
+            Vertical scrolling within the dataframe element is enabled when the
+            height does not accommodate all rows.
 
         use_container_width : bool
             Whether to override ``width`` with the width of the parent
@@ -343,42 +401,41 @@ class ArrowMixin:
             (default), the visibility of index columns is automatically
             determined based on the data.
 
-        column_order : Iterable of str or None
-            The ordered list of columns to display. If ``column_order`` is
-            ``None`` (default), Streamlit displays all columns in the order
-            inherited from the underlying data structure. If ``column_order``
-            is a list, the indicated columns will display in the order they
-            appear within the list. Columns may be omitted or repeated within
-            the list.
+        column_order : Iterable[str] or None
+            The ordered list of columns to display. If this is ``None``
+            (default), Streamlit displays all columns in the order inherited
+            from the underlying data structure. If this is a list, the
+            indicated columns will display in the order they appear within the
+            list. Columns may be omitted or repeated within the list.
 
             For example, ``column_order=("col2", "col1")`` will display
             ``"col2"`` first, followed by ``"col1"``, and will hide all other
             non-index columns.
 
+            ``column_order`` does not accept positional column indices and
+            can't move the index column(s).
+
         column_config : dict or None
-            Configuration to customize how columns display. If ``column_config``
-            is ``None`` (default), columns are styled based on the underlying
-            data type of each column.
+            Configuration to customize how columns are displayed. If this is
+            ``None`` (default), columns are styled based on the underlying data
+            type of each column.
 
             Column configuration can modify column names, visibility, type,
-            width, or format, among other things. ``column_config`` must be a
-            dictionary where each key is a column name and the associated value
-            is one of the following:
-
-            - ``None``: Streamlit hides the column.
-
-            - A string: Streamlit changes the display label of the column to
-              the given string.
-
-            - A column type within ``st.column_config``: Streamlit applies the
-              defined configuration to the column. For example, use
-              ``st.column_config.NumberColumn("Dollar values", format="$ %d")``
-              to change the displayed name of the column to "Dollar values"
-              and add a "$" prefix in each cell. For more info on the
-              available column types and config options, see
-              `Column configuration <https://docs.streamlit.io/develop/api-reference/data/st.column_config>`_.
-
-            To configure the index column(s), use ``_index`` as the column name.
+            width, format, and more. If this is a dictionary, the keys are
+            column names (strings) and/or positional column indices (integers),
+            and the values are one of the following:
+
+            - ``None`` to hide the column.
+            - A string to set the display label of the column.
+            - One of the column types defined under ``st.column_config``. For
+              example, to show a column as dollar amounts, use
+              ``st.column_config.NumberColumn("Dollar values", format="$ %d")``.
+              See more info on the available column types and config options
+              `here <https://docs.streamlit.io/develop/api-reference/data/st.column_config>`_.
+
+            To configure the index column(s), use ``"_index"`` as the column
+            name, or use a positional column index where ``0`` refers to the
+            first index column.
 
         key : str
             An optional string to use for giving this element a stable
@@ -399,8 +456,8 @@ class ArrowMixin:
               input widget.
 
             - ``"rerun"``: Streamlit will rerun the app when the user selects
-              rows or columns in the dataframe. In this case, ``st.dataframe``
-              will return the selection data as a dictionary.
+              rows, columns, or cells in the dataframe. In this case,
+              ``st.dataframe`` 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.
@@ -408,7 +465,7 @@ class ArrowMixin:
               as a dictionary.
 
         selection_mode : "single-row", "multi-row", "single-column", \
-            "multi-column", or Iterable of these
+            "multi-column", "single-cell", "multi-cell", or Iterable of these
             The types of selections Streamlit should allow when selections are
             enabled with ``on_select``. This can be one of the following:
 
@@ -416,8 +473,12 @@ class ArrowMixin:
             - "single-row": Only one row can be selected at a time.
             - "multi-column": Multiple columns can be selected at a time.
             - "single-column": Only one column can be selected at a time.
+            - "multi-cell": A rectangular range of cells can be selected.
+            - "single-cell": Only one cell can be selected at a time.
             - An ``Iterable`` of the above options: The table will allow
-              selection based on the modes specified.
+              selection based on the modes specified. For example, to allow the
+              user to select multiple rows and multiple cells, use
+              ``["multi-row", "multi-cell"]``.
 
             When column selections are enabled, column sorting is disabled.
 
@@ -426,6 +487,11 @@ class ArrowMixin:
             is ``None`` (default), Streamlit will use a default row height,
             which fits one line of text.
 
+        .. deprecated::
+            ``use_container_width`` is deprecated and will be removed in a
+            future release. For ``use_container_width=True``, use
+            ``width="stretch"``.
+
         Returns
         -------
         element or dict
@@ -572,23 +638,36 @@ class ArrowMixin:
                 enable_check_callback_rules=is_callback,
             )
 
+        if use_container_width is not None:
+            show_deprecation_warning(
+                make_deprecated_name_warning(
+                    "use_container_width",
+                    "width",
+                    "2025-12-31",
+                    "For `use_container_width=True`, use `width='stretch'`. "
+                    "For `use_container_width=False`, use `width='content'`.",
+                    include_st_prefix=False,
+                ),
+                show_in_browser=False,
+            )
+            if use_container_width:
+                width = "stretch"
+            elif not isinstance(width, int):
+                width = "content"
+
+        validate_width(width, allow_content=True)
+        validate_height(
+            height,
+            allow_content=False,
+            allow_stretch=False,
+            additional_allowed=["auto"],
+        )
+
         # Convert the user provided column config into the frontend compatible format:
         column_config_mapping = process_config_mapping(column_config)
 
         proto = ArrowProto()
 
-        if use_container_width is None:
-            # If use_container_width was not explicitly set by the user, we set
-            # it to True if width was not set explicitly, and False otherwise.
-            use_container_width = width is None
-
-        proto.use_container_width = use_container_width
-
-        if width:
-            proto.width = width
-        if height:
-            proto.height = height
-
         if row_height:
             proto.row_height = row_height
 
@@ -629,6 +708,13 @@ class ArrowMixin:
             )
         marshall_column_config(proto, column_config_mapping)
 
+        # Create layout configuration
+        # For height, only include it in LayoutConfig if it's not "auto"
+        # "auto" is the default behavior and doesn't need to be sent
+        layout_config = LayoutConfig(
+            width=width, height=height if height != "auto" else None
+        )
+
         if is_selection_activated:
             # If selection events are activated, we need to register the dataframe
             # element as a widget.
@@ -639,7 +725,6 @@ class ArrowMixin:
             proto.id = compute_and_register_element_id(
                 "dataframe",
                 user_key=key,
-                form_id=proto.form_id,
                 dg=self.dg,
                 data=proto.data,
                 width=width,
@@ -661,9 +746,9 @@ class ArrowMixin:
                 ctx=ctx,
                 value_type="string_value",
             )
-            self.dg._enqueue("arrow_data_frame", proto)
+            self.dg._enqueue("arrow_data_frame", proto, layout_config=layout_config)
             return widget_state.value
-        return self.dg._enqueue("arrow_data_frame", proto)
+        return self.dg._enqueue("arrow_data_frame", proto, layout_config=layout_config)
 
     @gather_metrics("table")
     def table(self, data: Data = None) -> DeltaGenerator: